diff --git a/include/imex/Dialect/XeTile/Transforms/Blocking.h b/include/imex/Dialect/XeTile/Transforms/Blocking.h
deleted file mode 100644
index 95a7473d7..000000000
--- a/include/imex/Dialect/XeTile/Transforms/Blocking.h
+++ /dev/null
@@ -1,113 +0,0 @@
-//===- Blocking.h ----------- Blocking Pass ---------*- C++ -*------------===//
-//
-// Copyright 2024 Intel Corporation
-// Part of the IMEX Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file contains lowering transformation for determing the problem size
-/// that can be handled by an XeGPU operator (hardware instruction). XeTile
-/// program can work one bigger problem size that cannot be handled by a
-/// hardware instruction. But it needs to be decomposed into smaller pieces
-/// such that each pieces can be handled by a hardware instruction.
-/////===----------------------------------------------------------------------===//
-#ifndef _XeTileTranformBase_H_INCLUDED_
-#define _XeTileTranformBase_H_INCLUDED_
-
-#include <llvm/IR/ValueMap.h>
-#include <llvm/Support/Debug.h>
-#include <mlir/Dialect/Arith/IR/Arith.h>
-#include <mlir/Dialect/Vector/IR/VectorOps.h>
-#include <mlir/IR/BuiltinOps.h>
-#include <mlir/Transforms/DialectConversion.h>
-#include <mlir/Transforms/OneToNTypeConversion.h>
-
-#include "imex/Dialect/XeTile/IR/XeTileOps.h"
-#include "imex/Utils/DebugUtils.h"
-#include "imex/Utils/PassWrapper.h"
-#include "imex/Utils/XeCommon.h"
-
-namespace imex {
-
-template <typename SourceOp, typename AnalysisT>
-class XeTileConversion : public imex::XeConversionPattern<AnalysisT> {
-public:
-  using OpAdaptor = typename SourceOp::Adaptor;
-  using OpPatternRewriter = typename mlir::PatternRewriter;
-
-  XeTileConversion(mlir::MLIRContext *context, XeTypeConverter &typeConverter,
-                   AnalysisT &analysis, mlir::PatternBenefit benefit = 1)
-      : XeConversionPattern<AnalysisT>(typeConverter, analysis,
-                                       SourceOp::getOperationName(), benefit,
-                                       context) {}
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::Operation *op,
-                  mlir::PatternRewriter &rewriter) const override final {
-    auto sourceOp = llvm::cast<SourceOp>(op);
-    OpAdaptor adaptor(op->getOperands(), sourceOp);
-    return matchAndRewrite(sourceOp, adaptor, rewriter);
-  }
-
-  virtual mlir::LogicalResult
-  matchAndRewrite(SourceOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const {
-    llvm_unreachable("must override matchAndRewrite or a rewrite method");
-  }
-
-  xetile::TileUnpackOp addUnpackOp(mlir::Value src,
-                                   OpPatternRewriter &rewriter) const {
-    auto srcTy = llvm::dyn_cast_if_present<mlir::VectorType>(src.getType());
-    assert(srcTy && srcTy.getRank() == 4);
-    auto shape = srcTy.getShape();
-    auto grids = shape.take_front(2);
-    auto innerBlocks = shape.take_back(2);
-    llvm::SmallVector<int64_t> unpackShape(
-        {grids[0] * innerBlocks[0], grids[1] * innerBlocks[1]});
-
-    auto unpackTy = mlir::VectorType::get(unpackShape, srcTy.getElementType());
-    return rewriter.create<xetile::TileUnpackOp>(
-        src.getLoc(), unpackTy, src,
-        mlir::DenseI64ArrayAttr::get(src.getContext(), innerBlocks));
-  }
-
-  mlir::Value addPackOp(mlir::Value src, llvm::ArrayRef<int64_t> targetBlkSizes,
-                        OpPatternRewriter &rewriter) const {
-    auto srcTy = mlir::dyn_cast<mlir::VectorType>(src.getType());
-    assert(srcTy && targetBlkSizes.size() == 2);
-    auto shape = srcTy.getShape();
-    llvm::SmallVector<int64_t> packShape(
-        {shape[0] / targetBlkSizes[0], shape[1] / targetBlkSizes[1],
-         targetBlkSizes[0], targetBlkSizes[1]});
-
-    auto packTy = mlir::VectorType::get(packShape, srcTy.getElementType());
-    auto packOp = rewriter.create<xetile::TilePackOp>(
-        src.getLoc(), packTy, src,
-        mlir::DenseI64ArrayAttr::get(src.getContext(), targetBlkSizes));
-    return packOp;
-  }
-
-  mlir::Value addUnpackAndPackOps(mlir::Value src,
-                                  llvm::ArrayRef<int64_t> targetBlocks,
-                                  OpPatternRewriter &rewriter) const {
-    auto unpack = addUnpackOp(src, rewriter);
-    return addPackOp(unpack, targetBlocks, rewriter);
-  }
-};
-
-template <template <typename> class TraitType, typename AnalysisT>
-class XeTileTraitConversion : public imex::XeConversionPattern<AnalysisT> {
-public:
-  XeTileTraitConversion(mlir::MLIRContext *context,
-                        XeTypeConverter &typeConverter, AnalysisT &analysis,
-                        mlir::PatternBenefit benefit = 1)
-      : XeConversionPattern<AnalysisT>(
-            typeConverter, analysis, mlir::Pattern::MatchTraitOpTypeTag(),
-            mlir::TypeID::get<TraitType>(), benefit, context) {}
-};
-} // namespace imex
-
-#endif
diff --git a/lib/Dialect/XeTile/Transforms/BlockingAnalysis.h b/include/imex/Dialect/XeTile/Transforms/BlockingAnalysis.h
similarity index 100%
rename from lib/Dialect/XeTile/Transforms/BlockingAnalysis.h
rename to include/imex/Dialect/XeTile/Transforms/BlockingAnalysis.h
diff --git a/include/imex/Dialect/XeTile/Transforms/Passes.h b/include/imex/Dialect/XeTile/Transforms/Passes.h
index 56dc14d26..17d26ad36 100644
--- a/include/imex/Dialect/XeTile/Transforms/Passes.h
+++ b/include/imex/Dialect/XeTile/Transforms/Passes.h
@@ -40,9 +40,6 @@ std::unique_ptr<mlir::Pass> createXeTileInitDuplicatePass();
 
 std::unique_ptr<mlir::Pass>
 createXeTileBlockingPass(const std::string &device = "pvc");
-std::unique_ptr<mlir::Pass>
-createNewXeTileBlockingPass(const std::string &device = "pvc");
-std::unique_ptr<mlir::Pass> createXeTileBlockAligningPass();
 std::unique_ptr<mlir::Pass> createXeTileWgToSgPass();
 std::unique_ptr<mlir::Pass> createXeTileCanonicalizationPass();
 
@@ -50,13 +47,6 @@ std::unique_ptr<mlir::Pass> createXeTileCanonicalizationPass();
 void populateXeTileInitDuplicatePatterns(imex::XeTypeConverter &converter,
                                          mlir::RewritePatternSet &patterns);
 
-///
-void populateXeTileBlockingPatterns(imex::XeTypeConverter &converter,
-                                    mlir::RewritePatternSet &patterns,
-                                    std::shared_ptr<XeuArchInterface> ptruArch);
-
-#define GEN_PASS_DECL_NEWXETILEBLOCKING
-#define GEN_PASS_DECL_XETILEBLOCKALIGNING
 #define GEN_PASS_DECL_XETILEBLOCKING
 #define GEN_PASS_DECL_XETILECANONICALIZATION
 #define GEN_PASS_DECL_XETILEINITDUPLICATE
diff --git a/include/imex/Dialect/XeTile/Transforms/Passes.td b/include/imex/Dialect/XeTile/Transforms/Passes.td
index 02ff3ad53..83c141718 100644
--- a/include/imex/Dialect/XeTile/Transforms/Passes.td
+++ b/include/imex/Dialect/XeTile/Transforms/Passes.td
@@ -34,53 +34,6 @@ def XeTileInitDuplicate : Pass<"xetile-init-duplicate", "::mlir::gpu::GPUModuleO
   let dependentDialects = ["imex::xetile::XeTileDialect"];
 }
 
-def XeTileBlocking : Pass<"xetile-blocking", "::mlir::gpu::GPUModuleOp">{
-  let summary = "transform XeTile large tiles(input) into arrays of smaller "
-                "blocks with appropriate size, such that the operator on each "
-                "of the blocks can be mapped into one hardware instruction.";
-
-  let description = [{
-    This transform pass preprocesses the xetile program by decomposing large XeTile tiles
-    into smaller ones that can be handled by a hardware instruction. This blocked layout
-    is represented by high dimension vectors, inner dimension matches to DPAS size config.
-    This lowers 2D vector to 4D vector.
-  }];
-
-  let constructor = "imex::createXeTileBlockingPass()";
-  let dependentDialects = ["imex::xetile::XeTileDialect",
-                           "mlir::arith::ArithDialect",
-                           "mlir::gpu::GPUDialect",
-                           "mlir::memref::MemRefDialect",
-                           "mlir::vector::VectorDialect"];
-
-  let options = [
-     Option<"device", "device", "std::string",
-            /*default=*/"\"pvc\"",
-            "gpu platform architecture where these ops are running">
- ];
-}
-
-
-// TODO: [block-aligning] remove the following code when upstreaming the pass.
-// The pass is not supposed to be exposed to users. Temporary keep in case we
-// need debug it for down stream development.
-def XeTileBlockAligning: Pass <"xetile-block-aligning", "::mlir::gpu::GPUModuleOp"> {
-  let summary = "optimize the performance for mma.";
-
-  let description = [{
-    This transform is to optimize performance by aligning the block size among operators
-    to reduce in-register data movements. Currently, it mainly focues on the alignment
-    between load and MMA operators.
-  }];
-
-  let constructor = "imex::createXeTileBlockAligningPass()";
-  let dependentDialects = ["imex::xetile::XeTileDialect",
-                           "mlir::arith::ArithDialect",
-                           "mlir::gpu::GPUDialect",
-                           "mlir::memref::MemRefDialect",
-                           "mlir::vector::VectorDialect"];
-}
-
 def XeTileWgToSg : Pass<"xetile-wg-to-sg", "::mlir::gpu::GPUModuleOp">{
   let summary = "Transform WG level XeTile code to SG XeTile";
 
@@ -116,7 +69,7 @@ def XeTileCanonicalization : Pass<"xetile-canonicalization", "::mlir::gpu::GPUMo
   ];
 }
 
-def NewXeTileBlocking : Pass<"new-xetile-blocking", "::mlir::gpu::GPUModuleOp">{
+def XeTileBlocking : Pass<"xetile-blocking", "::mlir::gpu::GPUModuleOp">{
   let summary = "transform XeTile large tiles(input) into arrays of smaller "
                 "blocks with appropriate size, such that the operator on each "
                 "of the blocks can be mapped into one hardware instruction.";
@@ -127,7 +80,7 @@ def NewXeTileBlocking : Pass<"new-xetile-blocking", "::mlir::gpu::GPUModuleOp">{
     the xetile-blocking pass.
   }];
 
-  let constructor = "imex::createNewXeTileBlockingPass()";
+  let constructor = "imex::createXeTileBlockingPass()";
   let dependentDialects = ["imex::xetile::XeTileDialect",
                            "mlir::arith::ArithDialect",
                            "mlir::math::MathDialect",
diff --git a/include/imex/Transforms/Passes.h b/include/imex/Transforms/Passes.h
index a697e1b49..6e6f7d1b6 100644
--- a/include/imex/Transforms/Passes.h
+++ b/include/imex/Transforms/Passes.h
@@ -34,7 +34,6 @@ std::unique_ptr<mlir::Pass> createBF16ToGPUPass();
 std::unique_ptr<mlir::Pass> createCastIndexPass();
 std::unique_ptr<mlir::Pass> createRemoveTemporariesPass();
 std::unique_ptr<mlir::Pass> createVectorLinearizePass();
-std::unique_ptr<mlir::Pass> createPropagatePackedLayoutPass();
 std::unique_ptr<mlir::Pass> createRemoveSingleElemVectorPass();
 std::unique_ptr<mlir::Pass>
 createOptimizeTransposePass(const std::string &device = "pvc");
diff --git a/include/imex/Transforms/Passes.td b/include/imex/Transforms/Passes.td
index 5717c996d..0002e5705 100644
--- a/include/imex/Transforms/Passes.td
+++ b/include/imex/Transforms/Passes.td
@@ -159,15 +159,6 @@ def VectorLinearize : Pass<"imex-vector-linearize"> {
   ];
 }
 
-def PropagatePackedLayout : Pass<"imex-propagate-packed-layout"> {
-  let summary = "Propagate packed layout (i.e. VNNI) through ops";
-  let constructor = "imex::createPropagatePackedLayoutPass()";
-
-  let dependentDialects = [
-    "::mlir::vector::VectorDialect"
-  ];
-}
-
 def RemoveSingleElemVector : Pass<"imex-remove-single-elem-vector"> {
   let summary = "Remove <1xT> vectors, and replace them with scalars.";
   let constructor = "imex::createRemoveSingleElemVectorPass()";
diff --git a/lib/Dialect/XeTile/Transforms/BlockAligning.cpp b/lib/Dialect/XeTile/Transforms/BlockAligning.cpp
deleted file mode 100644
index b579e7772..000000000
--- a/lib/Dialect/XeTile/Transforms/BlockAligning.cpp
+++ /dev/null
@@ -1,320 +0,0 @@
-//===------- BlockAligning.cpp ------ mma-opt Pass -------*- C++ ----*----===//
-//
-// Copyright 2024 Intel Corporation
-// Part of the IMEX Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file contains lowering transformation for optmizing mma performance
-/// by align the tile size of load based on the mma size for the dpas. The
-/// blocking pass could choose [32, 32] as block size for, e.g,
-/// %1 = xetile.init_tile ..., and [8, 16] as block size for A operand of
-/// e.g., %2 = xetile.tile_mma ... . Therefore, when %1 is loaded as A operand
-/// of %2, it will cause a lot of extract ops to extract 8x16 blocks from the
-/// 32x32 block, which is not efficiently supported by the hardware. But the
-/// hardware can efficiently extract 8x16 blocks from a 32x16 block.
-//===----------------------------------------------------------------------===//
-
-#include <mlir/Conversion/LLVMCommon/TypeConverter.h>
-#include <mlir/Dialect/Arith/IR/Arith.h>
-#include <mlir/Dialect/Func/IR/FuncOps.h>
-#include <mlir/Dialect/GPU/IR/GPUDialect.h>
-#include <mlir/Dialect/Index/IR/IndexDialect.h>
-#include <mlir/Dialect/Linalg/IR/Linalg.h>
-#include <mlir/Dialect/Linalg/Utils/Utils.h>
-#include <mlir/Dialect/MemRef/IR/MemRef.h>
-#include <mlir/Dialect/SCF/IR/SCF.h>
-#include <mlir/IR/BuiltinAttributes.h>
-#include <mlir/IR/PatternMatch.h>
-#include <mlir/Pass/Pass.h>
-#include <mlir/Support/LogicalResult.h>
-#include <mlir/Transforms/DialectConversion.h>
-#include <mlir/Transforms/GreedyPatternRewriteDriver.h>
-
-#include <llvm/ADT/SetVector.h>
-#include <llvm/Support/Debug.h>
-
-#include <optional>
-
-#include "imex/Dialect/XeTile/Transforms/Blocking.h"
-#include "imex/Dialect/XeTile/Transforms/Passes.h"
-#include "imex/Utils/DebugUtils.h"
-
-using namespace mlir;
-using namespace imex;
-namespace imex {
-#define GEN_PASS_DEF_XETILEBLOCKALIGNING
-#include "imex/Dialect/XeTile/Transforms/Passes.h.inc"
-} // namespace imex
-
-namespace imex {
-namespace BlockAligning {
-
-// reblocking the dense constant op if necessary to expected tiled shape
-struct ArithConstantOpPattern
-    : public XeTileConversion<mlir::arith::ConstantOp, PropagateAnalysis> {
-  using XeTileConversion<mlir::arith::ConstantOp,
-                         PropagateAnalysis>::XeTileConversion;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::arith::ConstantOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto blockSize = getValue(op);
-    auto value = llvm::dyn_cast<mlir::DenseElementsAttr>(op.getValue());
-
-    // it is not the target operator.
-    if (!blockSize || !value || value.getType().getRank() != 4)
-      return failure();
-
-    auto shape = value.getType().getShape();
-    auto oldBlockSize = shape.take_back(2);
-
-    // the blk size has been in the expected shape
-    if (oldBlockSize == blockSize.asArrayRef())
-      return failure();
-
-    auto newTy = mlir::VectorType::get({shape[0] * shape[2] / blockSize[0],
-                                        shape[1] * shape[3] / blockSize[1],
-                                        blockSize[0], blockSize[1]},
-                                       value.getElementType());
-
-    // TODO: can reshape reveal the pack logic?
-    value = value.reshape(newTy);
-    auto newOp = rewriter.create<mlir::arith::ConstantOp>(op.getLoc(), value);
-    auto packOp = addUnpackAndPackOps(newOp, oldBlockSize, rewriter);
-    rewriter.replaceOp(op, packOp);
-    return mlir::success();
-  }
-};
-
-// Updating the the body of SCF::ForOp when its init args are changed.
-struct SCFForOpPattern
-    : public XeTileConversion<mlir::scf::ForOp, PropagateAnalysis> {
-  using XeTileConversion<mlir::scf::ForOp, PropagateAnalysis>::XeTileConversion;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(mlir::scf::ForOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    // we need to update the SCF ForOp if the types of its init arg values
-    // do not match the types of the region iter args, or the init arg value
-    // is defined by a TilePackOp. Otherwise we can skip the op.
-    bool changed = false;
-    llvm::SmallVector<mlir::Value> newInitArgs;
-    llvm::SmallVector<mlir::DenseI64ArrayAttr> oldBlockSizes;
-    llvm::SmallVector<mlir::DenseI64ArrayAttr> newBlockSizes;
-    for (auto [i, arg] : llvm::enumerate(adaptor.getInitArgs())) {
-      auto blockArg = op.getRegionIterArg(i);
-      auto defOp = arg.getDefiningOp<xetile::TilePackOp>();
-      auto oldSize = defOp ? defOp.getInnerBlocksAttr() : DenseI64ArrayAttr();
-      auto newSize = defOp ? getValue(blockArg) : DenseI64ArrayAttr();
-      auto newArg =
-          defOp && newSize ? addUnpackAndPackOps(arg, newSize, rewriter) : arg;
-      oldBlockSizes.push_back(oldSize);
-      newBlockSizes.push_back(newSize);
-      newInitArgs.push_back(newArg);
-      changed |= (newArg.getType() != blockArg.getType());
-    }
-
-    if (!changed)
-      return mlir::failure();
-
-    auto newOp = rewriter.create<mlir::scf::ForOp>(
-        op.getLoc(), adaptor.getLowerBound(), adaptor.getUpperBound(),
-        adaptor.getStep(), newInitArgs);
-
-    mlir::Block *block = op.getBody();
-    mlir::Block *newBlock = newOp.getBody();
-    llvm::SmallVector<mlir::Value> newArguments;
-    auto numCtrlOprs = newOp.getNumInductionVars();
-    // remove the terminator of the new block
-    if (newBlock->mightHaveTerminator())
-      rewriter.eraseOp(newBlock->getTerminator());
-
-    // add UnpackOp and PackOp pairs to the block arguments
-    // if the corresponding init arg is repacked, such that
-    // the old unpack op using it in the body will be folded
-    for (auto [i, arg] : llvm::enumerate(newBlock->getArguments())) {
-      if (i < numCtrlOprs || !oldBlockSizes[i - numCtrlOprs]) {
-        newArguments.push_back(arg);
-      } else {
-        auto repackOp =
-            addUnpackAndPackOps(arg, oldBlockSizes[i - numCtrlOprs], rewriter);
-        newArguments.push_back(repackOp);
-      }
-    }
-    rewriter.mergeBlocks(block, newBlock, newArguments);
-
-    // update the yieldOp by adding UnpackOp and PackOp pairs
-    // if corresponding init arg is repacked.
-    auto yieldOp =
-        llvm::dyn_cast<scf::YieldOp>(newOp.getBody()->getTerminator());
-    mlir::OpBuilder::InsertionGuard g(rewriter);
-    rewriter.startOpModification(yieldOp);
-    for (auto [i, v] : llvm::enumerate(yieldOp.getResults())) {
-      if (newBlockSizes[i]) {
-        rewriter.setInsertionPointAfter(v.getDefiningOp());
-        auto repack = addUnpackAndPackOps(v, newBlockSizes[i], rewriter);
-        yieldOp->setOperand(i, repack);
-      }
-    }
-    rewriter.finalizeOpModification(yieldOp);
-
-    // Update the results
-    rewriter.setInsertionPointAfter(op);
-    llvm::SmallVector<mlir::Value> newValues;
-    for (auto [i, result] : llvm::enumerate(newOp->getResults())) {
-      if (oldBlockSizes[i]) {
-        auto unpack = addUnpackAndPackOps(result, oldBlockSizes[i], rewriter);
-        newValues.push_back(unpack);
-      } else {
-        newValues.push_back(result);
-      }
-    }
-    rewriter.replaceOp(op, newValues);
-
-    return mlir::success();
-  }
-};
-
-// Update the innerblock size of the result tile. We only update the second
-// dimention of the innerblock size to use large load size but small compute
-// size
-struct InitTileOpPattern
-    : public XeTileConversion<xetile::InitTileOp, PropagateAnalysis> {
-  using XeTileConversion<xetile::InitTileOp,
-                         PropagateAnalysis>::XeTileConversion;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::InitTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tileTy = op.getType();
-    auto oldBlockSize = tileTy.getInnerBlocks();
-    auto blockSize = getValue(op);
-
-    // it is not the target to be updated
-    if (!blockSize || oldBlockSize[1] == blockSize[1])
-      return mlir::failure();
-
-    auto newBlockSize = mlir::DenseI64ArrayAttr::get(
-        getContext(), {oldBlockSize[0], blockSize[1]});
-
-    auto attr = imex::xetile::XeTileAttr::get(
-        op.getContext(), tileTy.getSgMap(), tileTy.getWgMap(),
-        tileTy.getOrder(), newBlockSize, tileTy.getMemorySpace());
-
-    auto newTileTy = imex::xetile::TileType::get(tileTy.getShape(),
-                                                 tileTy.getElementType(), attr);
-
-    rewriter.startOpModification(op);
-    op.getTile().setType(newTileTy);
-    rewriter.finalizeOpModification(op);
-    return mlir::success();
-  }
-};
-
-// Update the result shape of the load if its source is updated
-struct LoadTileOpPattern
-    : public XeTileConversion<xetile::LoadTileOp, PropagateAnalysis> {
-  using XeTileConversion<xetile::LoadTileOp,
-                         PropagateAnalysis>::XeTileConversion;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::LoadTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tileTy = op.getSource().getType();
-    auto resTy = op.getValue().getType();
-    auto blockSize = tileTy.getInnerBlocks();
-
-    // it is not the target since the source is not updated
-    if (resTy.getShape().take_back(2) == blockSize.asArrayRef())
-      return mlir::failure();
-
-    auto shape = tileTy.getShape();
-    auto vecTy = ::mlir::VectorType::get({shape[0] / blockSize[0],
-                                          shape[1] / blockSize[1], blockSize[0],
-                                          blockSize[1]},
-                                         tileTy.getElementType());
-
-    auto newOp = rewriter.create<imex::xetile::LoadTileOp>(
-        op.getLoc(), vecTy, adaptor.getSource(), op.getPaddingAttr());
-
-    auto repackOp =
-        addUnpackAndPackOps(newOp, resTy.getShape().take_back(2), rewriter);
-    rewriter.replaceOp(op, repackOp);
-    return mlir::success();
-  }
-};
-
-struct UpdateTileOffsetOpPattern
-    : public XeTileConversion<xetile::UpdateTileOffsetOp, PropagateAnalysis> {
-  using XeTileConversion<xetile::UpdateTileOffsetOp,
-                         PropagateAnalysis>::XeTileConversion;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::UpdateTileOffsetOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    if (adaptor.getTile().getType() == op.getResult().getType())
-      return mlir::failure();
-
-    rewriter.replaceOpWithNewOp<xetile::UpdateTileOffsetOp>(
-        op, adaptor.getTile().getType(), adaptor.getTile(),
-        adaptor.getOffsetX(), adaptor.getOffsetY());
-    return mlir::success();
-  }
-};
-
-} // namespace BlockAligning
-
-void populateXeTileBlockAligningPatterns(imex::XeTypeConverter &converter,
-                                         mlir::RewritePatternSet &patterns,
-                                         PropagateAnalysis &analysis) {
-  patterns.insert<
-      BlockAligning::ArithConstantOpPattern, BlockAligning::SCFForOpPattern,
-      BlockAligning::InitTileOpPattern, BlockAligning::LoadTileOpPattern,
-      BlockAligning::UpdateTileOffsetOpPattern>(patterns.getContext(),
-                                                converter, analysis);
-}
-
-// TODO: [block-aligning] remove the following code when upstreaming the pass.
-// The pass is not supposed to be exposed to users. Temporary keep in case we
-// need debug it for down stream development.
-class XeTileBlockAligningPass
-    : public impl::XeTileBlockAligningBase<XeTileBlockAligningPass> {
-public:
-  void runOnOperation() override {
-    mlir::MLIRContext &context = getContext();
-    auto mod = this->getOperation();
-
-    // skip functions with XeTile.TileType inputs and outputs
-    if (!isSupportedModule(mod)) {
-      mod.emitOpError(
-          "currently FunctionType with xetile.TileType is not supported.");
-      return signalPassFailure();
-    }
-
-    auto &analysis = getAnalysis<PropagateAnalysis>();
-    mlir::RewritePatternSet patterns(&context);
-    XeTypeConverter typeConverter(context);
-    populateXeTileBlockAligningPatterns(typeConverter, patterns, analysis);
-
-    // Use TopDown traversal order, and only look at existing ops
-    // to simpliy the code logic and speedup the pass
-    mlir::GreedyRewriteConfig config;
-    config.enableRegionSimplification = GreedySimplifyRegionLevel::Disabled;
-    config.useTopDownTraversal = true;
-    config.strictMode = GreedyRewriteStrictness::ExistingAndNewOps;
-    if (failed(
-            applyPatternsAndFoldGreedily(mod, std::move(patterns), config))) {
-      return signalPassFailure();
-    }
-  }
-};
-
-/// Create a pass
-std::unique_ptr<::mlir::Pass> createXeTileBlockAligningPass() {
-  return std::make_unique<XeTileBlockAligningPass>();
-}
-} // namespace imex
diff --git a/lib/Dialect/XeTile/Transforms/Blocking.cpp b/lib/Dialect/XeTile/Transforms/Blocking.cpp
index 02f8584e8..2bb17797c 100644
--- a/lib/Dialect/XeTile/Transforms/Blocking.cpp
+++ b/lib/Dialect/XeTile/Transforms/Blocking.cpp
@@ -14,6 +14,9 @@
 /// such that each pieces can be handled by a hardware instruction.
 ///
 //===----------------------------------------------------------------------===//
+#include <mlir/Analysis/DataFlow/ConstantPropagationAnalysis.h>
+#include <mlir/Analysis/DataFlow/DeadCodeAnalysis.h>
+#include <mlir/Analysis/DataFlow/SparseAnalysis.h>
 #include <mlir/Conversion/LLVMCommon/TypeConverter.h>
 #include <mlir/Dialect/Arith/IR/Arith.h>
 #include <mlir/Dialect/Func/IR/FuncOps.h>
@@ -21,6 +24,7 @@
 #include <mlir/Dialect/Index/IR/IndexDialect.h>
 #include <mlir/Dialect/Linalg/IR/Linalg.h>
 #include <mlir/Dialect/Linalg/Utils/Utils.h>
+#include <mlir/Dialect/Math/IR/Math.h>
 #include <mlir/Dialect/MemRef/IR/MemRef.h>
 #include <mlir/Dialect/SCF/IR/SCF.h>
 #include <mlir/IR/BuiltinAttributes.h>
@@ -31,18 +35,24 @@
 #include <mlir/Transforms/DialectConversion.h>
 #include <mlir/Transforms/GreedyPatternRewriteDriver.h>
 
+#include <llvm/ADT/DenseMapInfo.h>
+#include <llvm/ADT/STLExtras.h>
 #include <llvm/ADT/SetVector.h>
+#include <llvm/ADT/SmallVector.h>
 #include <llvm/Support/Debug.h>
 
 #include <algorithm>
 #include <optional>
+#include <set>
+#include <tuple>
 
-#include "imex/Dialect/XeTile/Transforms/Blocking.h"
+#include "imex/Dialect/XeTile/Transforms/BlockingAnalysis.h"
 #include "imex/Dialect/XeTile/Transforms/Passes.h"
 #include "imex/Utils/DebugUtils.h"
 #include "imex/Utils/XeArch.h"
 
 using namespace mlir;
+using namespace llvm;
 using namespace imex;
 namespace imex {
 #define GEN_PASS_DEF_XETILEBLOCKING
@@ -50,213 +60,92 @@ namespace imex {
 } // namespace imex
 
 namespace imex {
-
-extern void
-populateXeTileBlockAligningPatterns(imex::XeTypeConverter &converter,
-                                    mlir::RewritePatternSet &patterns,
-                                    PropagateAnalysis &analysis);
-
-enum OpType { Prefetch, Load, Store, Elementwise, Transpose };
-
-// Find the maximum divisible number between minHeight/Width and maxHeight/Width
-// and use that as the inner block sizes.
-int findMaxInnerBlockSize(int num, int maxNum, int minNum) {
-  for (int i = maxNum; i >= minNum; i--) {
-    if (num % i == 0) {
-      return i;
-    }
-  }
-  return -1;
+namespace Blocking {
+
+static xetile::TileUnpackOp
+addUnpackOp(mlir::Value src, mlir::ConversionPatternRewriter &rewriter) {
+  auto srcTy = llvm::dyn_cast_if_present<mlir::VectorType>(src.getType());
+  assert(srcTy && srcTy.getRank() == 4);
+  auto shape = srcTy.getShape();
+  auto grids = shape.take_front(2);
+  auto innerBlocks = shape.take_back(2);
+  llvm::SmallVector<int64_t> unpackShape(
+      {grids[0] * innerBlocks[0], grids[1] * innerBlocks[1]});
+
+  auto unpackTy = mlir::VectorType::get(unpackShape, srcTy.getElementType());
+  return rewriter.create<xetile::TileUnpackOp>(
+      src.getLoc(), unpackTy, src,
+      mlir::DenseI64ArrayAttr::get(src.getContext(), innerBlocks));
 }
 
-llvm::SmallVector<int64_t, 2>
-getInnerBlockHeightWidth(int maxHeight, int maxWidth, int minHeight,
-                         int minWidth, int height, int width) {
-
-  llvm::SmallVector<int64_t, 2> innerBlockSizes;
-
-  if (height < minHeight || width < minWidth) {
-    return {};
-  }
-
-  if (height == maxHeight || height < maxHeight) {
-    innerBlockSizes.push_back(height);
-  } else if (height > maxHeight) {
-    auto innerBlockHeight =
-        imex::findMaxInnerBlockSize(height, maxHeight, minHeight);
-    if (innerBlockHeight != -1)
-      innerBlockSizes.push_back(innerBlockHeight);
-    else {
-      llvm::dbgs() << "Invalid Block Height Shape \n";
-      return {};
-    }
-  }
-
-  if (width == maxWidth || width < maxWidth) {
-    innerBlockSizes.push_back(width);
-  } else if (width > maxWidth) {
-    auto innerBlockWidth =
-        imex::findMaxInnerBlockSize(width, maxWidth, minWidth);
-    if (innerBlockWidth != -1)
-      innerBlockSizes.push_back(innerBlockWidth);
-    else {
-      llvm::dbgs() << "Invalid Block Width Shape \n";
-      return {};
-    }
-  }
-  return innerBlockSizes;
+static mlir::Value addPackOp(mlir::Value src,
+                             llvm::ArrayRef<int64_t> targetBlkSizes,
+                             mlir::ConversionPatternRewriter &rewriter) {
+  auto srcTy = mlir::dyn_cast<mlir::VectorType>(src.getType());
+  assert(srcTy && targetBlkSizes.size() == 2);
+  auto shape = srcTy.getShape();
+  llvm::SmallVector<int64_t> packShape({shape[0] / targetBlkSizes[0],
+                                        shape[1] / targetBlkSizes[1],
+                                        targetBlkSizes[0], targetBlkSizes[1]});
+
+  auto packTy = mlir::VectorType::get(packShape, srcTy.getElementType());
+  auto packOp = rewriter.create<xetile::TilePackOp>(
+      src.getLoc(), packTy, src,
+      mlir::DenseI64ArrayAttr::get(src.getContext(), targetBlkSizes));
+  return packOp;
 }
 
-// TODO: placeholder, replace it with uArch interface
-template <OpType op>
-llvm::SmallVector<int64_t, 2>
-getInnerBlockSizes(mlir::Operation *operation, mlir::Type elemTy, int height,
-                   int width, std::shared_ptr<XeuArchInterface> uArchInterface,
-                   bool vnni = false, bool transpose = false) {
-  assert(elemTy.isIntOrFloat());
-  int elementSize = elemTy.getIntOrFloatBitWidth();
-  if (op == OpType::Load && elementSize > 16 && vnni) {
-    llvm::dbgs() << "load with VNNI for \"" << elemTy
-                 << "\" is not supported.\n";
-    return {};
-  }
-
-  int maxHeight, maxWidth, minHeight, minWidth;
-
-  if (op == OpType::Load) {
-
-    mlir::FailureOr<LoadStore2DConfig> params = uArchInterface->get2DLoadConfig(
-        operation, elementSize, vnni, transpose);
-    if (mlir::succeeded(params)) {
-      maxHeight = params->blockHeight.max;
-      minHeight = params->blockHeight.min;
-      maxWidth = params->blockWidth.max;
-      minWidth = params->blockWidth.min;
-    } else {
-      llvm::dbgs() << "Invalid Config Params \n";
-      return {};
-    }
-
-    return imex::getInnerBlockHeightWidth(maxHeight, maxWidth, minHeight,
-                                          minWidth, height, width);
-  }
-
-  if (op == OpType::Prefetch) {
-
-    mlir::FailureOr<LoadStore2DConfig> params =
-        uArchInterface->get2DPrefetchConfig(operation, elementSize);
-    if (mlir::succeeded(params)) {
-      maxHeight = params->blockHeight.max;
-      minHeight = params->blockHeight.min;
-      maxWidth = params->blockWidth.max;
-      minWidth = params->blockWidth.min;
-    } else {
-      llvm::dbgs() << "Invalid Config Params \n";
-      return {};
-    }
-
-    return imex::getInnerBlockHeightWidth(maxHeight, maxWidth, minHeight,
-                                          minWidth, height, width);
-  }
-
-  if (op == OpType::Store) {
-
-    mlir::FailureOr<LoadStore2DConfig> params =
-        uArchInterface->get2DStoreConfig(elementSize);
-    if (mlir::succeeded(params)) {
-      maxHeight = params->blockHeight.max;
-      minHeight = params->blockHeight.min;
-      maxWidth = params->blockWidth.max;
-      minWidth = params->blockWidth.min;
-    } else {
-      llvm::dbgs() << "Invalid Config Params \n";
-      return {};
-    }
-
-    return imex::getInnerBlockHeightWidth(maxHeight, maxWidth, minHeight,
-                                          minWidth, height, width);
-  }
-
-  if (op == OpType::Elementwise) {
-    int64_t subgroupSize = uArchInterface->getOneGRFSizeBits() / elementSize;
-
-    maxHeight = 1;
-    minHeight = 1;
-    maxWidth = subgroupSize;
-    minWidth = 1;
-
-    return imex::getInnerBlockHeightWidth(maxHeight, maxWidth, minHeight,
-                                          minWidth, height, width);
-  }
-
-  if (op == OpType::Transpose) {
-    // TODO: get from uArch?
-    maxHeight = 16;
-    minHeight = 1;
-    maxWidth = 8;
-    minWidth = 1;
-
-    return imex::getInnerBlockHeightWidth(maxHeight, maxWidth, minHeight,
-                                          minWidth, height, width);
-  }
+/// OpConversionPatternWithAnalysis is a wrapper around OpConversionPattern
+/// but takes an extra AnalysisT object as an argument, such that patterns
+/// can leverage the analysis results.
+template <typename SourceOp, typename AnalysisT>
+class OpConversionPatternWithAnalysis
+    : public mlir::OpConversionPattern<SourceOp> {
+public:
+  using OpPatternRewriter = typename mlir::ConversionPatternRewriter;
 
-  llvm_unreachable("Unsupported.");
-  return {};
-}
+  OpConversionPatternWithAnalysis(mlir::MLIRContext *context,
+                                  AnalysisT &analysis)
+      : mlir::OpConversionPattern<SourceOp>(context), analysis(analysis) {}
 
-// works similar to getUsers. If the user is a SCF::ForOp,
-// it will return the users of corresponding scf::ForOp argument.
-// TODO: make it to be general to handle composite ops, e.g,
-// SCF::ForOp, SCF::WhileOp, etc.
-static llvm::SmallVector<mlir::Operation *> getEffectiveUsers(mlir::Value val) {
-  llvm::SmallVector<mlir::Operation *> users;
-  for (auto user : val.getUsers()) {
-    if (auto forOp = llvm::dyn_cast<mlir::scf::ForOp>(user)) {
-      auto arg = getArgForOperand(forOp, val);
-      users.append(arg.user_begin(), arg.user_end());
-    } else {
-      users.push_back(user);
-    }
-  }
-  return users;
-}
+protected:
+  AnalysisT &analysis;
+};
 
-static llvm::SmallVector<unsigned int>
-getMMASize(mlir::Type elemTy, const int APrecision, const int BPrecision,
-           const int CPrecision, const int DPrecision,
-           std::shared_ptr<XeuArchInterface> uArchInterface) {
-  assert(elemTy.isIntOrFloat() && "unsupported element type.");
-  auto dpasParams = uArchInterface->getDPASConfig(APrecision, BPrecision,
-                                                  CPrecision, DPrecision);
-  return llvm::SmallVector<unsigned int>(
-      {dpasParams.m, dpasParams.k, dpasParams.n});
-}
+/// OpTraitConversionPatternWithAnalysis is a wrapper around
+/// OpTraitConversionPattern but takes an extra AnalysisT object as an argument,
+/// such that patterns can leverage the analysis results.
+template <template <typename> class TraitType, typename AnalysisT>
+class OpTraitConversionPatternWithAnalysis
+    : public mlir::OpTraitConversionPattern<TraitType> {
+public:
+  OpTraitConversionPatternWithAnalysis(mlir::MLIRContext *context,
+                                       AnalysisT &analysis,
+                                       PatternBenefit benefit = 1)
+      : mlir::OpTraitConversionPattern<TraitType>(context, benefit),
+        analysis(analysis) {}
+
+protected:
+  AnalysisT &analysis;
+};
 
 // It blocks/extends a 2D constant dense vector into a
 // 4D vector with the last 2 dim corresponding to block size.
+// which is chosed based on requests from its users.
 // example: arith.constant dense<0.0>: vector<32x32xf16>
 //      --> arith.constant dense<0.0>: vector<4x2x8x16xf16>
-// [8, 16] is the block size.
+// assuming [8, 16] is the block size.
 struct ArithConstantOpPattern
-    : public XeTileConversion<mlir::arith::ConstantOp, TileUsageAnalysis> {
-
-  using XeTileConversion<mlir::arith::ConstantOp,
-                         TileUsageAnalysis>::XeTileConversion;
+    : public OpConversionPatternWithAnalysis<mlir::arith::ConstantOp,
+                                             BlockingAnalysis> {
 
-  ArithConstantOpPattern(mlir::MLIRContext *context,
-                         imex::XeTypeConverter &converter,
-                         TileUsageAnalysis &analysis,
-                         std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
-
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+  using OpConversionPatternWithAnalysis<
+      mlir::arith::ConstantOp,
+      BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
   mlir::LogicalResult
   matchAndRewrite(mlir::arith::ConstantOp op, OpAdaptor adaptor,
                   OpPatternRewriter &rewriter) const override {
-    auto loc = op.getLoc();
     auto value = llvm::dyn_cast<mlir::DenseElementsAttr>(op.getValue());
 
     // TODO: it maybe unstable to determine whether doing blocking or not
@@ -264,22 +153,21 @@ struct ArithConstantOpPattern
     if (!value || value.getType().getRank() != 2)
       return mlir::failure();
 
-    auto shape = value.getType().getShape();
-    auto blkSZ =
-        getInnerBlockSizes<Load>(op.getOperation(), value.getElementType(),
-                                 shape[0], shape[1], this->uArchInterface);
-    if (blkSZ.empty())
-      return rewriter.notifyMatchFailure(op, "Invalid inner block sizes");
-
-    auto newTy = mlir::VectorType::get(
-        {shape[0] / blkSZ[0], shape[1] / blkSZ[1], blkSZ[0], blkSZ[1]},
-        value.getElementType());
+    auto blockSize = analysis.getDefBlockSize(op.getResult());
+    if (!blockSize)
+      return rewriter.notifyMatchFailure(op, "Invalid block size.");
 
-    // TODO: it is logically incorrect to reshape a dense value to a vector
-    // type.
-    //  it doesnot show the impact of pack effect. It works on some specific
-    //  cases in which all elements has the same value, but not general.
+    auto shape = value.getType().getShape();
+    auto newTy =
+        mlir::VectorType::get({shape[0] / blockSize[0], shape[1] / blockSize[1],
+                               blockSize[0], blockSize[1]},
+                              value.getElementType());
+
+    // TODO: it is logically incorrect to reshape a dense value.
+    // it doesn't show the impact of pack effect. It works on some
+    // cases in which all elements has the same value, but not general.
     value = value.reshape(newTy);
+    auto loc = op.getLoc();
     auto newOp = rewriter.create<mlir::arith::ConstantOp>(loc, value);
     auto unpack = addUnpackOp(newOp, rewriter);
 
@@ -288,415 +176,455 @@ struct ArithConstantOpPattern
   }
 };
 
-// Blocks a vector.create_mask op such that, ideally, it matches its consuming
-// select op (which is an elementwise op). In this way, during the lowering to
-// XeGPU, there will be a one-to-one correspondence and an
-// unrealized_conversion_cast will not be needed.
-struct VectorCreateMaskOpPattern
-    : public XeTileConversion<mlir::vector::CreateMaskOp, TileUsageAnalysis> {
-
-  using XeTileConversion<mlir::vector::CreateMaskOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  VectorCreateMaskOpPattern(mlir::MLIRContext *context,
-                            imex::XeTypeConverter &converter,
-                            TileUsageAnalysis &analysis,
-                            std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
+// It updates init_tile by attaching innerBlock attribute to the result
+// tile. The block size is choosed based on requests from its users.
+struct InitTileOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::InitTileOp,
+                                             BlockingAnalysis> {
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+  using OpConversionPatternWithAnalysis<
+      xetile::InitTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
-  mlir::LogicalResult
-  matchAndRewrite(mlir::vector::CreateMaskOp op, OpAdaptor adaptor,
+  ::mlir::LogicalResult
+  matchAndRewrite(xetile::InitTileOp op, OpAdaptor adaptor,
                   OpPatternRewriter &rewriter) const override {
-    auto res = op.getResult();
-    auto resType = res.getType();
-    if (resType.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
-
-    // Only two cases are supported for now:
-    // 1.The first operand is a constant equal to the first dimension of the
-    // output shape (i.e., all rows are enabled). In other words, masking
-    // columns within a row is supported.
-    // 2.The second operand is a constant equal to the second dimension of the
-    // output shape (i.e., all columns are enabled).
-    auto shape = resType.getShape();
-    APInt cstOp0, cstOp1;
-    if (!(matchPattern(op->getOperand(0), m_ConstantInt(&cstOp0)) &&
-          cstOp0.getSExtValue() == shape[0]) &&
-        !(matchPattern(op->getOperand(1), m_ConstantInt(&cstOp1)) &&
-          cstOp1.getSExtValue() == shape[1])) {
-      op->emitOpError() << "Unsupported operands";
-      return mlir::failure();
-    }
+    auto tileTy = op.getType();
+    auto shape = tileTy.getShape();
+    if (tileTy.getRank() != 2)
+      return rewriter.notifyMatchFailure(
+          op, "Skipped InitTileOp because the result tile is not rank 2.\n");
 
-    auto blocks = getInnerBlockSizes<Elementwise>(
-        op, resType.getElementType(), shape[0], shape[1], this->uArchInterface);
+    auto innerBlockAttr = tileTy.getInnerBlocks();
 
-    if (blocks.empty()) {
-      op->emitOpError() << "Invalid inner block sizes";
+    // skip it if innerBlocks has been set by user or compiler.
+    if (innerBlockAttr)
       return mlir::failure();
-    }
 
-    // TODO: support blocking the outer dimension.
-    if (blocks[0] != 1) {
-      op->emitOpError() << "Unsupported inner block sizes";
-      return mlir::failure();
-    }
+    auto blockSize = analysis.getDefBlockSize(op.getTile());
+    if (!blockSize)
+      return rewriter.notifyMatchFailure(op, "Invalid block size.");
 
-    auto newTy = mlir::VectorType::get(
-        {shape[0] / blocks[0], shape[1] / blocks[1], blocks[0], blocks[1]},
-        resType.getElementType());
-    Location loc = op->getLoc();
-    rewriter.startOpModification(op);
-    // Due to the simplifications mentioned above, for now, the index operands
-    // are not adjusted. In fact, only the first index operand (masked rows) or
-    // the second index operand (masked columns) will be used during the
-    // lowering to XeGPU.
-    op->setOperands({op->getOperand(0), op->getOperand(1), op->getOperand(0),
-                     op->getOperand(1)});
-    res.setType(newTy);
-    rewriter.finalizeOpModification(op);
-    rewriter.setInsertionPointAfter(op);
-    auto unpack = rewriter.create<xetile::TileUnpackOp>(
-        loc, resType, res, mlir::DenseI64ArrayAttr::get(getContext(), blocks));
-    rewriter.replaceAllUsesExcept(res, unpack.getResult(), unpack);
-    return mlir::success();
-  }
-};
+    innerBlockAttr =
+        mlir::DenseI64ArrayAttr::get(getContext(), blockSize.asArrayRef());
 
-// Pattern for generic elemetwise ops. Blocks op according to
-// getInnerBlocks<Elementwise>. Pack/Unpack ops are inserted on the ops
-// boundaries if needed.
-struct VectorizableOpPattern
-    : public XeTileTraitConversion<mlir::OpTrait::Vectorizable,
-                                   TileUsageAnalysis> {
+    if (innerBlockAttr.empty())
+      return rewriter.notifyMatchFailure(op, "Invalid inner block sizes ");
 
-  using XeTileTraitConversion::XeTileTraitConversion;
+    auto attr = imex::xetile::XeTileAttr::get(
+        op.getContext(), tileTy.getSgMap(), tileTy.getWgMap(),
+        tileTy.getOrder(), innerBlockAttr, tileTy.getMemorySpace());
 
-  VectorizableOpPattern(mlir::MLIRContext *context,
-                        imex::XeTypeConverter &converter,
-                        TileUsageAnalysis &analysis,
-                        std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileTraitConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
+    auto elemTy = tileTy.getElementType();
+    auto newTileTy = imex::xetile::TileType::get(shape, elemTy, attr);
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+    auto newOp = rewriter.create<xetile::InitTileOp>(
+        op.getLoc(), mlir::TypeRange({newTileTy}), op->getOperands(),
+        op->getAttrs());
 
-  mlir::LogicalResult
-  matchAndRewrite(mlir::Operation *op,
-                  mlir::PatternRewriter &rewriter) const override {
-    if (op->getNumResults() != 1)
-      return rewriter.notifyMatchFailure(op, "op must have 1 result");
+    rewriter.replaceOp(op, newOp);
 
-    auto res = op->getResult(0);
-    auto resType = mlir::dyn_cast<mlir::VectorType>(res.getType());
-    if (!resType || resType.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
+    return mlir::success();
+  }
+};
 
-    auto shape = resType.getShape();
-    auto blocks = getInnerBlockSizes<Elementwise>(
-        op, resType.getElementType(), shape[0], shape[1], this->uArchInterface);
+// It updates tile operand of prefetch_tile.
+struct PrefetchTileOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::PrefetchTileOp,
+                                             BlockingAnalysis> {
 
-    if (blocks.empty()) {
-      op->emitOpError() << "Invalid inner block sizes ";
-      return mlir::failure();
-    }
+  using OpConversionPatternWithAnalysis<
+      xetile::PrefetchTileOp,
+      BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
-    auto newTy = mlir::VectorType::get(
-        {shape[0] / blocks[0], shape[1] / blocks[1], blocks[0], blocks[1]},
-        resType.getElementType());
+  ::mlir::LogicalResult
+  matchAndRewrite(xetile::PrefetchTileOp op, OpAdaptor adaptor,
+                  OpPatternRewriter &rewriter) const override {
+    auto tile = adaptor.getTile();
+    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
+    auto blockSize = tileTy.getInnerBlocks();
+    // define op is not updated yet.
+    if (!blockSize)
+      return failure();
 
-    Location loc = op->getLoc();
     rewriter.startOpModification(op);
-    for (auto &&[i, arg] : llvm::enumerate(op->getOperands())) {
-      auto srcTy = mlir::dyn_cast<mlir::VectorType>(arg.getType());
-      if (!srcTy || srcTy.getRank() != 2)
-        continue;
+    op->setOperand(0, tile);
+    rewriter.finalizeOpModification(op);
 
-      auto unpackShape = srcTy.getShape();
-      int64_t packShape[] = {unpackShape[0] / blocks[0],
-                             unpackShape[1] / blocks[1], blocks[0], blocks[1]};
+    return mlir::success();
+  }
+};
 
-      auto packTy = mlir::VectorType::get(packShape, srcTy.getElementType());
-      mlir::Value packOp = rewriter.create<xetile::TilePackOp>(
-          loc, packTy, arg, mlir::DenseI64ArrayAttr::get(getContext(), blocks));
+// It updates load_tile to reveal effects of innerblock attribute by
+// representing value as 4D vector. An unpack op is added at the end
+// to make this change to be transparent to its users.
+struct LoadTileOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::LoadTileOp,
+                                             BlockingAnalysis> {
 
-      op->setOperand(i, packOp);
-    }
+  using OpConversionPatternWithAnalysis<
+      xetile::LoadTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
-    res.setType(newTy);
-    rewriter.finalizeOpModification(op);
+  ::mlir::LogicalResult
+  matchAndRewrite(xetile::LoadTileOp op, OpAdaptor adaptor,
+                  OpPatternRewriter &rewriter) const override {
+    auto source = adaptor.getSource();
+    auto tileTy = mlir::cast<xetile::TileType>(source.getType());
+    auto blockSize = tileTy.getInnerBlocks();
+    auto rank = op.getValue().getType().getRank();
 
-    mlir::OpBuilder::InsertionGuard g(rewriter);
-    rewriter.setInsertionPointAfter(op);
-    auto unpack = rewriter.create<xetile::TileUnpackOp>(
-        loc, resType, res, mlir::DenseI64ArrayAttr::get(getContext(), blocks));
+    if (!blockSize || rank == 4)
+      return rewriter.notifyMatchFailure(
+          op, "Input is not updated or the op has been updated.\n");
 
-    rewriter.replaceAllUsesExcept(res, unpack.getResult(), unpack);
+    auto shape = tileTy.getShape();
+    auto vecTy = ::mlir::VectorType::get({shape[0] / blockSize[0],
+                                          shape[1] / blockSize[1], blockSize[0],
+                                          blockSize[1]},
+                                         tileTy.getElementType());
+    mlir::Value newOp = rewriter.create<xetile::LoadTileOp>(
+        op.getLoc(), vecTy, adaptor.getSource(),
+        op.getPadding().value_or(mlir::Attribute()));
+    newOp = addUnpackOp(newOp, rewriter);
+    rewriter.replaceOp(op, newOp);
     return mlir::success();
   }
 };
 
-template <typename OpTy>
-struct TransposeOpPattern : public XeTileConversion<OpTy, TileUsageAnalysis> {
+// It updates store_tile to reveal effects of innerblock attribute.
+// It uses pack op to align the shape of its vector value to the tile shape.
+struct StoreTileOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::StoreTileOp,
+                                             BlockingAnalysis> {
 
-  using XeTileConversion<OpTy, TileUsageAnalysis>::XeTileConversion;
-  using OpAdaptor = typename OpTy::Adaptor;
+  using OpConversionPatternWithAnalysis<
+      xetile::StoreTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
-  TransposeOpPattern(mlir::MLIRContext *context,
-                     imex::XeTypeConverter &converter,
-                     TileUsageAnalysis &analysis,
-                     std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion<OpTy, TileUsageAnalysis>(context, converter,
-                                                  analysis) {
-    this->uArchInterface = ptruArch;
+  ::mlir::LogicalResult
+  matchAndRewrite(xetile::StoreTileOp op, OpAdaptor adaptor,
+                  OpPatternRewriter &rewriter) const override {
+    auto value = adaptor.getValue();
+    auto valTy = mlir::dyn_cast<mlir::VectorType>(value.getType());
+    auto tile = adaptor.getTile();
+    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
+    auto blockSize = tileTy.getInnerBlocks();
+
+    // its inputs has not been updated yet.
+    if (blockSize && valTy.getRank() == 2) {
+      value = addPackOp(value, blockSize.asArrayRef(), rewriter);
+      rewriter.replaceOpWithNewOp<xetile::StoreTileOp>(op, value, tile);
+      return mlir::success();
+    }
+    return mlir::failure();
   }
+};
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+// It updates update_tile_offset to reveal effects of innerblock attribute
+// by updating the type of it result.
+struct UpdateTileOffsetOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::UpdateTileOffsetOp,
+                                             BlockingAnalysis> {
 
-  mlir::LogicalResult
-  matchAndRewrite(OpTy op, OpAdaptor adaptor,
-                  mlir::PatternRewriter &rewriter) const override {
-    auto res = op.getResult();
-    auto resType = mlir::cast<mlir::VectorType>(res.getType());
-    if (resType.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
+  using OpConversionPatternWithAnalysis<
+      xetile::UpdateTileOffsetOp,
+      BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
-    auto permutation = op.getPermutation();
-    if (permutation != mlir::ArrayRef<int64_t>({1, 0}))
-      return rewriter.notifyMatchFailure(op, "Unsupported permutation");
+  ::mlir::LogicalResult
+  matchAndRewrite(xetile::UpdateTileOffsetOp op, OpAdaptor adaptor,
+                  OpPatternRewriter &rewriter) const override {
+    auto tile = adaptor.getTile();
+    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
+    auto blockSize = tileTy.getInnerBlocks();
+    // define op is not updated yet.
+    if (!blockSize)
+      return failure();
 
-    auto shape = resType.getShape();
-    auto blocks = getInnerBlockSizes<Transpose>(
-        op, resType.getElementType(), shape[0], shape[1], this->uArchInterface);
+    rewriter.replaceOpWithNewOp<xetile::UpdateTileOffsetOp>(
+        op, tileTy, tile, adaptor.getOffsetX(), adaptor.getOffsetY());
+    return mlir::success();
+  }
+};
 
-    if (blocks.size() != 2)
-      return rewriter.notifyMatchFailure(op, "Invalid inner block sizes");
+// It updates tile_mma to reveal effects of innerblock attribute.
+// Values will be reprented as 4D vectors. An unpack op is applied
+// to its result to make the change transparent to its users.
+struct TileMMAOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::TileMMAOp,
+                                             BlockingAnalysis> {
 
-    int64_t inBlocks[2] = {blocks[1], blocks[0]};
+  using OpConversionPatternWithAnalysis<
+      xetile::TileMMAOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
-    auto newSrcTy = mlir::VectorType::get(
-        {shape[1] / blocks[1], shape[0] / blocks[0], blocks[1], blocks[0]},
-        resType.getElementType());
+  ::mlir::LogicalResult
+  matchAndRewrite(xetile::TileMMAOp op, OpAdaptor adaptor,
+                  OpPatternRewriter &rewriter) const override {
+    auto resultTy = op.getResult().getType();
+    if (resultTy.getRank() != 2)
+      return rewriter.notifyMatchFailure(
+          op, "The result of tile_mma must be 2D vector.\n");
 
-    auto newDstTy = mlir::VectorType::get(
-        {shape[0] / blocks[0], shape[1] / blocks[1], blocks[0], blocks[1]},
-        resType.getElementType());
+    auto a = adaptor.getA();
+    auto b = adaptor.getB();
+    auto c = adaptor.getC();
 
-    mlir::Value arg = adaptor.getVector();
+    assert(a && b && "a operand or b operand is (are) missing.\n");
 
-    Location loc = op->getLoc();
-    mlir::Value pack = rewriter.create<xetile::TilePackOp>(
-        loc, newSrcTy, arg,
-        mlir::DenseI64ArrayAttr::get(op.getContext(), inBlocks));
+    auto getBlockingSize = [&](mlir::Value val,
+                               int pos) -> mlir::FailureOr<Block> {
+      auto blk = analysis.getUseBlockSize(val, UsePoint(op, pos));
+      if (!blk)
+        return rewriter.notifyMatchFailure(op, "Invalid block size.");
+      return blk;
+    };
 
-    int64_t newPermutation[4] = {1, 0, 3, 2};
-    mlir::Value transpose =
-        rewriter.create<OpTy>(loc, newDstTy, pack, newPermutation);
+    auto aBlockSize = getBlockingSize(op.getA(), 0);
+    auto bBlockSize = getBlockingSize(op.getB(), 1);
+    if (mlir::failed(aBlockSize) || mlir::failed(bBlockSize))
+      return mlir::failure();
+    if (c) {
+      auto cBlockSize = getBlockingSize(op.getC(), 2);
+      if (mlir::failed(cBlockSize))
+        return mlir::failure();
+      c = addPackOp(c, cBlockSize->asArrayRef(), rewriter);
+    }
 
-    mlir::Value unpack = rewriter.create<xetile::TileUnpackOp>(
-        loc, resType, transpose,
-        mlir::DenseI64ArrayAttr::get(op.getContext(), blocks));
+    a = addPackOp(a, aBlockSize->asArrayRef(), rewriter);
+    b = addPackOp(b, bBlockSize->asArrayRef(), rewriter);
 
-    rewriter.replaceOp(op, unpack);
+    assert(
+        mlir::dyn_cast<mlir::VectorType>(a.getType()).getRank() == 4 &&
+        mlir::dyn_cast<mlir::VectorType>(b.getType()).getRank() == 4 &&
+        (!c || mlir::dyn_cast<mlir::VectorType>(c.getType()).getRank() == 4) &&
+        "a, b and c (if has) should be transformed into 4D vectors.\n");
 
+    Block dBlockSize(aBlockSize->asArrayRef()[0], bBlockSize->asArrayRef()[1]);
+    auto shape = resultTy.getShape();
+    auto vecTy = ::mlir::VectorType::get({shape[0] / dBlockSize[0],
+                                          shape[1] / dBlockSize[1],
+                                          dBlockSize[0], dBlockSize[1]},
+                                         resultTy.getElementType());
+
+    mlir::Value newOp = rewriter.create<imex::xetile::TileMMAOp>(
+        op.getLoc(), vecTy, a, b, c, nullptr, nullptr, nullptr);
+    newOp = addUnpackOp(newOp, rewriter);
+    rewriter.replaceOp(op, newOp);
     return mlir::success();
   }
 };
 
-struct VectorMultiDimReductionOpPattern
-    : public XeTileConversion<mlir::vector::MultiDimReductionOp,
-                              TileUsageAnalysis> {
-  using XeTileConversion<mlir::vector::MultiDimReductionOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  VectorMultiDimReductionOpPattern(mlir::MLIRContext *context,
-                                   imex::XeTypeConverter &converter,
-                                   TileUsageAnalysis &analysis,
-                                   std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
+struct TileReductionOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::ReductionOp,
+                                             BlockingAnalysis> {
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+  using OpConversionPatternWithAnalysis<
+      xetile::ReductionOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
   mlir::LogicalResult
-  matchAndRewrite(mlir::vector::MultiDimReductionOp op, OpAdaptor adaptor,
+  matchAndRewrite(xetile::ReductionOp op, OpAdaptor adaptor,
                   OpPatternRewriter &rewriter) const override {
-    auto loc = op.getLoc();
+    auto source = op.getSource();
+    auto srcTy = source.getType();
     auto reductionDims = op.getReductionDims();
-    auto srcTy = op.getSource().getType();
-    auto shape = srcTy.getShape();
 
     if (srcTy.getRank() != 2 || reductionDims.size() != 1)
       return rewriter.notifyMatchFailure(
           op, "source type is not 2D vector or reduction dims are not 1");
 
-    auto blkSizes = getInnerBlockSizes<Elementwise>(
-        op, srcTy.getElementType(), shape[0], shape[1], this->uArchInterface);
-
-    if (blkSizes.empty())
-      return rewriter.notifyMatchFailure(op, "Invalid inner block sizes");
+    auto blkSize = analysis.getUseBlockSize(source, UsePoint(op, 0));
+    if (!blkSize)
+      return rewriter.notifyMatchFailure(op, "Invalid block size.");
 
     // reduction on one dim becomes reduction on two dims after blocking.
     // For example:
-    // multi_reduction<add>, %e, %a[1]: vector<16x32xf16> to vector<16xf16>
+    // reduce<add>, %e [1]: vector<16x32xf16> to vector<16x1xf16>
     // will be transformed to
-    // multi_reduction<add>, %e, %a[1, 3]: vector<16x2x1x16xf16> to
-    // vector<16x1xf16>
+    // reduce<add>, %e [1, 3]: vector<16x2x1x16xf16> to
+    // vector<16x1x1x1xf16>
     auto dim = reductionDims[0];
-    auto newReductionDims = rewriter.getDenseI64ArrayAttr({dim, dim + 2});
-
-    auto newDestShape =
-        (dim == 0)
-            ? llvm::SmallVector<int64_t>({shape[1] / blkSizes[1], blkSizes[1]})
-            : llvm::SmallVector<int64_t>({shape[0] / blkSizes[0], blkSizes[0]});
-    auto newDestType =
-        mlir::VectorType::get(newDestShape, srcTy.getElementType());
-
-    auto newSource =
-        addPackOp(adaptor.getSource(), {blkSizes[0], blkSizes[1]}, rewriter);
-    auto newAcc = rewriter.create<mlir::vector::ShapeCastOp>(loc, newDestType,
-                                                             adaptor.getAcc());
-    auto newOp = rewriter.create<mlir::vector::MultiDimReductionOp>(
-        loc, newDestType, op.getKindAttr(), newSource, newAcc,
-        newReductionDims);
-    auto castOp = rewriter.create<mlir::vector::ShapeCastOp>(
-        loc, op.getDest().getType(), newOp);
-    rewriter.replaceOp(op, castOp.getResult());
 
+    auto ctx = op.getContext();
+    auto shape = srcTy.getShape();
+    auto newReductionDims = mlir::DenseI64ArrayAttr::get(ctx, {dim, dim + 2});
+    llvm::SmallVector<int64_t> resultShape(
+        {shape[0] / blkSize[0], shape[1] / blkSize[1], blkSize[0], blkSize[1]});
+    for (auto dim : newReductionDims.asArrayRef())
+      resultShape[dim] = 1;
+
+    auto elemTy = srcTy.getElementType();
+    auto resultType = mlir::VectorType::get(resultShape, elemTy);
+
+    auto newSource = addPackOp(source, {blkSize[0], blkSize[1]}, rewriter);
+    mlir::Value newOp = rewriter.create<xetile::ReductionOp>(
+        op.getLoc(), resultType, op.getKind(), newSource, newReductionDims);
+    newOp = addUnpackOp(newOp, rewriter);
+    rewriter.replaceOp(op, newOp);
     return mlir::success();
   }
 };
 
-struct TileReductionOpPattern
-    : public XeTileConversion<xetile::ReductionOp, TileUsageAnalysis> {
-
-  using XeTileConversion<xetile::ReductionOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  TileReductionOpPattern(mlir::MLIRContext *context,
-                         imex::XeTypeConverter &converter,
-                         TileUsageAnalysis &analysis,
-                         std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
+struct TileBroadcastOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::BroadcastOp,
+                                             BlockingAnalysis> {
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+  using OpConversionPatternWithAnalysis<
+      xetile::BroadcastOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
   mlir::LogicalResult
-  matchAndRewrite(xetile::ReductionOp op, OpAdaptor adaptor,
+  matchAndRewrite(xetile::BroadcastOp op, OpAdaptor adaptor,
                   OpPatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
-    auto srcTy = op.getSource().getType();
+    auto src = op.getSource();
+    auto srcTy = src.getType();
     auto elemTy = srcTy.getElementType();
-    auto shape = srcTy.getShape();
-    auto reductionDims = op.getReductionDims();
+    auto broadcastDims = op.getBroadcastDim();
 
-    if (srcTy.getRank() != 2 || reductionDims.size() != 1)
+    if (srcTy.getRank() != 2 || broadcastDims.size() != 1)
       return rewriter.notifyMatchFailure(
-          op, "source type is not 2D vector or reduction dims are not 1");
+          op, "source type is not 2D vector or rank of broadcastDims is not 1");
 
-    auto blkSizes = getInnerBlockSizes<Elementwise>(
-        op, elemTy, shape[0], shape[1], this->uArchInterface);
+    auto srcBlkSize = analysis.getUseBlockSize(src, UsePoint(op, 0));
+    auto resBlkSize = analysis.getDefBlockSize(op.getResult());
+    if (!srcBlkSize || !resBlkSize)
+      return rewriter.notifyMatchFailure(op, "Invalid block size.");
 
-    if (blkSizes.empty())
-      return rewriter.notifyMatchFailure(op, "Invalid inner block sizes");
+    auto outShape = op.getResult().getType().getShape();
 
-    // reduction on one dim becomes reduction on two dims after blocking.
+    // TODO: move this into analysis
+    llvm::SmallVector<int64_t> resultShape(
+        {outShape[0], outShape[1] / resBlkSize[1], 1, resBlkSize[1]});
+
+    auto newSource = addPackOp(adaptor.getSource(),
+                               {srcBlkSize[0], srcBlkSize[1]}, rewriter);
+
+    auto resultType = mlir::VectorType::get(resultShape, elemTy);
+
+    // broadcast on one dim becomes broadcast on two dims after blocking.
     // For example:
-    // reduce<add>, %e [1]: vector<16x32xf16> to vector<16xf16>
+    // broadcast %a [0]: vector<1x32xf16> to vector<16x32xf16>
     // will be transformed to
-    // reduce<add>, %e [1, 3]: vector<16x2x1x16xf16> to
-    // vector<16x1xf16>
-    auto dim = reductionDims[0];
-    auto newReductionDims =
+    // broadcast %a [0, 2]: vector<1x2x1x16xf16> to vector<16x2x1x16xf16>
+    auto dim = broadcastDims[0];
+    auto newBroadcastDims =
         mlir::DenseI64ArrayAttr::get(op.getContext(), {dim, dim + 2});
-    llvm::SmallVector<int64_t> newDestShape({shape[0] / blkSizes[0],
-                                             shape[1] / blkSizes[1],
-                                             blkSizes[0], blkSizes[1]});
-    for (auto dim : newReductionDims.asArrayRef()) {
-      newDestShape[dim] = 1;
-    }
+    mlir::Value newOp = rewriter.create<xetile::BroadcastOp>(
+        loc, resultType, newSource, newBroadcastDims);
+    newOp = addUnpackOp(newOp, rewriter);
+    rewriter.replaceOp(op, newOp);
+    return mlir::success();
+  }
+};
+
+struct TileTransposeOpPattern
+    : public OpConversionPatternWithAnalysis<xetile::TransposeOp,
+                                             BlockingAnalysis> {
+  using OpConversionPatternWithAnalysis<
+      xetile::TransposeOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
+
+  mlir::LogicalResult
+  matchAndRewrite(xetile::TransposeOp op, OpAdaptor adaptor,
+                  OpPatternRewriter &rewriter) const override {
+    auto input = op.getVector();
+    auto inputTy = input.getType();
+    auto result = op.getResult();
+    auto resultTy = result.getType();
+    if (resultTy.getRank() != 2)
+      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
+
+    auto permutation = op.getPermutation();
+    if (permutation != mlir::ArrayRef<int64_t>({1, 0}))
+      return rewriter.notifyMatchFailure(op, "Unsupported permutation");
+
+    UsePoint p(op, 0);
+    auto inBlockSize = analysis.getUseBlockSize(input, p);
+    auto outBlockSize = analysis.getDefBlockSize(result);
+    if (!inBlockSize || !outBlockSize)
+      return rewriter.notifyMatchFailure(op, "Invalid block size.");
+
+    auto srcShape = inputTy.getShape();
+    auto newSrcTy = mlir::VectorType::get({srcShape[0] / inBlockSize[0],
+                                           srcShape[1] / inBlockSize[1],
+                                           inBlockSize[0], inBlockSize[1]},
+                                          inputTy.getElementType());
+    auto resShape = resultTy.getShape();
+    auto newDstTy = mlir::VectorType::get({resShape[0] / outBlockSize[0],
+                                           resShape[1] / outBlockSize[1],
+                                           outBlockSize[0], outBlockSize[1]},
+                                          resultTy.getElementType());
+
+    mlir::Value src = adaptor.getVector();
+
+    auto ctxt = op.getContext();
+    auto blockAttr =
+        mlir::DenseI64ArrayAttr::get(ctxt, inBlockSize.asArrayRef());
+    Location loc = op->getLoc();
+    mlir::Value pack =
+        rewriter.create<xetile::TilePackOp>(loc, newSrcTy, src, blockAttr);
+
+    int64_t newPermutation[4] = {1, 0, 3, 2};
+    mlir::Value transpose = rewriter.create<xetile::TransposeOp>(
+        loc, newDstTy, pack, newPermutation);
 
-    auto newDestType =
-        mlir::VectorType::get(newDestShape, srcTy.getElementType());
+    blockAttr = mlir::DenseI64ArrayAttr::get(ctxt, outBlockSize.asArrayRef());
+    mlir::Value unpack = rewriter.create<xetile::TileUnpackOp>(
+        loc, resultTy, transpose, blockAttr);
 
-    auto newSource =
-        addPackOp(adaptor.getSource(), {blkSizes[0], blkSizes[1]}, rewriter);
-    auto newDest = rewriter.create<xetile::ReductionOp>(
-        loc, newDestType, op.getKind(), newSource, newReductionDims);
-    auto unpack = addUnpackOp(newDest.getResult(), rewriter);
     rewriter.replaceOp(op, unpack);
+
     return mlir::success();
   }
 };
 
-struct TileBroadcastOpPattern
-    : public XeTileConversion<xetile::BroadcastOp, TileUsageAnalysis> {
-
-  using XeTileConversion<xetile::BroadcastOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  TileBroadcastOpPattern(mlir::MLIRContext *context,
-                         imex::XeTypeConverter &converter,
-                         TileUsageAnalysis &analysis,
-                         std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
+struct VectorizableOpPattern
+    : public OpTraitConversionPatternWithAnalysis<mlir::OpTrait::Vectorizable,
+                                                  BlockingAnalysis> {
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+  using OpTraitConversionPatternWithAnalysis::
+      OpTraitConversionPatternWithAnalysis;
 
   mlir::LogicalResult
-  matchAndRewrite(xetile::BroadcastOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto loc = op.getLoc();
-    auto srcTy = op.getSource().getType();
-    auto elemTy = srcTy.getElementType();
-    auto shape = srcTy.getShape();
-    auto broadcastDims = op.getBroadcastDim();
-
-    if (srcTy.getRank() != 2 || broadcastDims.size() != 1)
-      return rewriter.notifyMatchFailure(
-          op, "source type is not 2D vector or rank of broadcastDims is not 1");
+  matchAndRewrite(mlir::Operation *op, llvm::ArrayRef<mlir::Value> operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    if (op->getNumResults() != 1)
+      return rewriter.notifyMatchFailure(op, "op must have 1 result");
 
-    auto inBlkSizes = getInnerBlockSizes<Elementwise>(
-        op, elemTy, shape[0], shape[1], this->uArchInterface);
+    auto res = op->getResult(0);
+    auto resType = mlir::dyn_cast<mlir::VectorType>(res.getType());
+    if (!resType || resType.getRank() != 2)
+      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
 
-    auto outShape = op.getResult().getType().getShape();
-    auto outBlkSizes = getInnerBlockSizes<Elementwise>(
-        op, elemTy, outShape[0], outShape[1], this->uArchInterface);
+    auto blockSize =
+        analysis.getUseBlockSize(op->getOperand(0), UsePoint(op, 0));
+    if (!blockSize)
+      return rewriter.notifyMatchFailure(op, "Invalid block size.");
 
-    if (inBlkSizes.empty() || outBlkSizes.empty())
-      return rewriter.notifyMatchFailure(op, "Invalid inner block sizes");
+    auto shape = resType.getShape();
+    auto elemTy = resType.getElementType();
+    auto blockSizeAttr =
+        mlir::DenseI64ArrayAttr::get(getContext(), blockSize.asArrayRef());
+    int64_t packShape[] = {shape[0] / blockSize[0], shape[1] / blockSize[1],
+                           blockSize[0], blockSize[1]};
 
-    llvm::SmallVector<int64_t> newDestShape({outShape[0] / outBlkSizes[0],
-                                             outShape[1] / outBlkSizes[1],
-                                             outBlkSizes[0], outBlkSizes[1]});
+    auto newTy = mlir::VectorType::get(packShape, elemTy);
 
-    auto newSource = addPackOp(adaptor.getSource(),
-                               {inBlkSizes[0], inBlkSizes[1]}, rewriter);
+    Location loc = op->getLoc();
+    mlir::OpBuilder::InsertionGuard g(rewriter);
+    llvm::SmallVector<mlir::Value> newOperands;
+    for (auto &&[i, arg] : llvm::enumerate(operands)) {
+      auto argTy = mlir::dyn_cast<mlir::VectorType>(arg.getType());
+      if (!argTy || argTy.getRank() != 2) {
+        newOperands.push_back(arg);
+        continue;
+      }
+      mlir::Value packOp = addPackOp(arg, blockSize.asArrayRef(), rewriter);
+      newOperands.push_back(packOp);
+    }
 
-    auto newDestType =
-        mlir::VectorType::get(newDestShape, srcTy.getElementType());
+    mlir::OperationState opState(loc, op->getName(), newOperands,
+                                 mlir::TypeRange(newTy), op->getAttrs(),
+                                 op->getSuccessors());
 
-    // broadcast on one dim becomes broadcast on two dims after blocking.
-    // For example:
-    // broadcast %a [0]: vector<1x32xf16> to vector<16x32xf16>
-    // will be transformed to
-    // broadcast %a [0, 2]: vector<1x2x1x16xf16> to vector<16x2x1x16xf16>
-    auto dim = broadcastDims[0];
-    auto newBroadcastDims =
-        mlir::DenseI64ArrayAttr::get(op.getContext(), {dim, dim + 2});
-    auto newDest = rewriter.create<xetile::BroadcastOp>(
-        loc, newDestType, newSource, newBroadcastDims);
-    auto unpack = addUnpackOp(newDest.getResult(), rewriter);
+    auto newOp = rewriter.create(opState);
+    auto unpack = rewriter.create<xetile::TileUnpackOp>(
+        loc, resType, newOp->getResult(0), blockSizeAttr);
     rewriter.replaceOp(op, unpack);
     return mlir::success();
   }
@@ -705,18 +633,11 @@ struct TileBroadcastOpPattern
 // It rewrites the SCF forOp, it mainly updates the arguments of its
 // region block. unpack ops are added for VectorType operands if needed.
 struct SCFForOpPattern
-    : public XeTileConversion<mlir::scf::ForOp, TileUsageAnalysis> {
+    : public OpConversionPatternWithAnalysis<mlir::scf::ForOp,
+                                             BlockingAnalysis> {
 
-  using XeTileConversion<mlir::scf::ForOp, TileUsageAnalysis>::XeTileConversion;
-
-  SCFForOpPattern(mlir::MLIRContext *context, imex::XeTypeConverter &converter,
-                  TileUsageAnalysis &analysis,
-                  std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
-
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+  using OpConversionPatternWithAnalysis<
+      mlir::scf::ForOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
   ::mlir::LogicalResult
   matchAndRewrite(mlir::scf::ForOp op, OpAdaptor adaptor,
@@ -724,31 +645,36 @@ struct SCFForOpPattern
     // we don't need to update the forOp if it has no region
     // iter args, or the region iter args type are not changed.
     bool changed = false;
-    for (unsigned i = 0; i < op.getNumRegionIterArgs(); i++) {
-      auto initArg = adaptor.getInitArgs()[i];
-      auto regionArg = op.getRegionIterArg(i);
-      changed |= (initArg.getType() != regionArg.getType()) ||
-                 bool(initArg.getDefiningOp<xetile::TileUnpackOp>());
+    for (auto [arg1, arg2] :
+         llvm::zip_equal(op.getInitArgs(), adaptor.getInitArgs())) {
+      changed |= (arg1 != arg2);
     }
     if (!changed)
       return mlir::failure();
 
-    // preprocess the init args and remove the unpackOp by
-    // adding pack op with the same innerblock size, so that
-    // they can be folded (removed).
+    // add packOp for vector type operands if needed.
     llvm::SmallVector<mlir::Value> newInitArgs;
-    for (auto arg : adaptor.getInitArgs()) {
-      if (auto defOp = arg.getDefiningOp<xetile::TileUnpackOp>()) {
-        auto packOp = addPackOp(arg, defOp.getInnerBlocks(), rewriter);
-        newInitArgs.push_back(packOp);
+    for (auto [arg1, arg2] :
+         llvm::zip_equal(op.getRegionIterArgs(), adaptor.getInitArgs())) {
+      if (mlir::isa<mlir::VectorType>(arg1.getType())) {
+        auto block = analysis.getDefBlockSize(arg1);
+        if (!block) { // block could be null if the arg is not used in the loop
+          auto argNo = arg1.getArgNumber() - 1;
+          auto yieldOp = op.getBody()->getTerminator();
+          auto opr = yieldOp->getOperand(argNo);
+          block = analysis.getDefBlockSize(opr);
+        }
+        auto pack = addPackOp(arg2, block.asArrayRef(), rewriter);
+        newInitArgs.push_back(pack);
       } else {
-        newInitArgs.push_back(arg);
+        newInitArgs.push_back(arg2);
       }
     }
 
     auto newOp = rewriter.create<mlir::scf::ForOp>(
         op.getLoc(), adaptor.getLowerBound(), adaptor.getUpperBound(),
         adaptor.getStep(), newInitArgs);
+
     mlir::Block *newBlock = newOp.getBody();
     // remove the terminator of the new block
     if (newBlock->mightHaveTerminator())
@@ -758,22 +684,24 @@ struct SCFForOpPattern
     mlir::OpBuilder::InsertionGuard g(rewriter);
     rewriter.setInsertionPointToStart(newBlock);
 
+    mlir::Block *block = op.getBody();
+
     // contruct the inputs for the new scf::for block.
     // An unpackOp is inserted for the corresponding init arg
     // of the new block if its init value is updated with a pack op.
     llvm::SmallVector<mlir::Value> newArguments;
-    for (auto [i, arg] : llvm::enumerate(newBlock->getArguments())) {
-      if (i && newInitArgs[i - 1].getDefiningOp<xetile::TilePackOp>()) {
-        auto unpack = addUnpackOp(arg, rewriter);
+    for (auto [arg1, arg2] :
+         llvm::zip_equal(block->getArguments(), newBlock->getArguments())) {
+      auto block = analysis.getDefBlockSize(arg1);
+      if (mlir::isa<mlir::VectorType>(arg1.getType()) && block) {
+        auto unpack = addUnpackOp(arg2, rewriter);
         newArguments.push_back(unpack);
       } else {
-        newArguments.push_back(arg);
+        newArguments.push_back(arg2);
       }
     }
 
     rewriter.restoreInsertionPoint(savedIP);
-
-    mlir::Block *block = op.getBody();
     rewriter.mergeBlocks(block, newBlock, newArguments);
 
     llvm::SmallVector<mlir::Value> newValues;
@@ -799,414 +727,143 @@ struct SCFForOpPattern
 // This op pattern will insert a pack op to make it consistent with the
 // corresponding argument type.
 struct SCFYieldOpPattern
-    : public XeTileConversion<mlir::scf::YieldOp, TileUsageAnalysis> {
-
-  using XeTileConversion<mlir::scf::YieldOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  SCFYieldOpPattern(mlir::MLIRContext *context,
-                    imex::XeTypeConverter &converter,
-                    TileUsageAnalysis &analysis,
-                    std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
+    : public OpConversionPatternWithAnalysis<mlir::scf::YieldOp,
+                                             BlockingAnalysis> {
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+  using OpConversionPatternWithAnalysis<
+      mlir::scf::YieldOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
   ::mlir::LogicalResult
   matchAndRewrite(mlir::scf::YieldOp op, OpAdaptor adaptor,
                   OpPatternRewriter &rewriter) const override {
-    auto forOp = op->getParentOfType<mlir::scf::ForOp>();
-    if (!forOp)
-      return mlir::failure();
-
-    bool changed = false;
-    for (auto [i, v] : llvm::enumerate(adaptor.getResults())) {
-      if (auto defOp = v.getDefiningOp<xetile::TileUnpackOp>()) {
-        // get InnerBlock size from the corresponding output type
-        auto ty =
-            mlir::dyn_cast<mlir::VectorType>(forOp->getResult(i).getType());
-        if (ty && ty.getRank() == 4) {
-          auto innerBlock = ty.getShape().take_back(2);
-          auto packOp = addPackOp(v, innerBlock, rewriter);
-          rewriter.startOpModification(op);
-          op->setOperand(i, packOp);
-          rewriter.finalizeOpModification(op);
-          changed = true;
-        }
-      }
-    }
-    return mlir::success(changed);
-  }
-};
-
-// It updates init_tile by attaching innerBlock attribute to the result
-// tile. The block size is choosed based on how the tile is used, including
-// prefetch, load, store. Since hardware support different sizes for them.
-struct InitTileOpPattern
-    : public XeTileConversion<xetile::InitTileOp, TileUsageAnalysis> {
-
-  using XeTileConversion<xetile::InitTileOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  InitTileOpPattern(mlir::MLIRContext *context,
-                    imex::XeTypeConverter &converter,
-                    TileUsageAnalysis &analysis,
-                    std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
-
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::InitTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tileTy = op.getType();
-    if (tileTy.getRank() != 2)
-      return rewriter.notifyMatchFailure(
-          op, "Skipped InitTileOp because the result tile is not rank 2.\n");
-
-    auto innerBlocks = tileTy.getInnerBlocks();
-    auto memorySpace = op.getSourceMemorySpaceAsInt();
-
-    // skip it if innerBlocks has been set by user or compiler.
-    if (innerBlocks)
-      return mlir::failure();
-
-    auto elemTy = tileTy.getElementType();
-    int elementSize = elemTy.getIntOrFloatBitWidth();
-
-    if (memorySpace == 3) {                    // for shared memory
-      const unsigned int lscConstraints = 512; // 512 bytes constraint by lsc
-      const unsigned int subgroupSize = 16;
-      auto shape = tileTy.getShape();
-      int64_t innerBlockSizes[2];
-      // prefer to use gather loads with 16 simd lanes
-      innerBlockSizes[0] = shape[0] % subgroupSize == 0 ? 16 : 1;
-      innerBlockSizes[1] =
-          (lscConstraints * 8) / (elementSize * innerBlockSizes[0]);
-      innerBlockSizes[1] =
-          std::min<int64_t>(innerBlockSizes[1], tileTy.getShape()[1]);
-      innerBlocks = mlir::DenseI64ArrayAttr::get(getContext(), innerBlockSizes);
-    } else { // for global memory
-      if (isForPrefetch(op)) {
-        innerBlocks = mlir::DenseI64ArrayAttr::get(
-            getContext(), getInnerBlockSizes<Prefetch>(
-                              op.getOperation(), elemTy, tileTy.getShape()[0],
-                              tileTy.getShape()[1], this->uArchInterface));
-      } else if (isForLoad(op)) {
-
-        // Set transpose and vnni
-        bool vnni = false;
-        bool transpose = false;
-
-        auto order = tileTy.getOrder();
-        if (order[0] == 0 && order[1] == 1)
-          transpose = true;
-
-        for (auto user : getEffectiveUsers(op)) {
-          if (auto loadTileOp = llvm::dyn_cast<xetile::LoadTileOp>(user)) {
-            if (isForDPASB(loadTileOp) && elementSize < 32) {
-              vnni = true;
-              break;
-            }
-          }
-        }
 
-        if (vnni && transpose && elementSize < 32) {
-          int factor = 32 / elementSize;
-          vnni = false;
-          llvm::SmallVector<int64_t, 2> innerBlock = getInnerBlockSizes<Load>(
-              op.getOperation(), mlir::FloatType::getF32(getContext()),
-              tileTy.getShape()[1], (tileTy.getShape()[0]) / factor,
-              this->uArchInterface, vnni, transpose);
-          std::swap(innerBlock[0], innerBlock[1]);
-          innerBlock[0] *= factor;
-          innerBlocks = mlir::DenseI64ArrayAttr::get(getContext(), innerBlock);
-
-        } else if (transpose && elementSize < 32) {
-          return rewriter.notifyMatchFailure(op, "Invalid transpose.");
-        } else {
-          innerBlocks = mlir::DenseI64ArrayAttr::get(
-              getContext(),
-              getInnerBlockSizes<Load>(
-                  op.getOperation(), elemTy, tileTy.getShape()[0],
-                  tileTy.getShape()[1], this->uArchInterface, vnni, transpose));
-        }
-      } else if (isForStore(op)) {
-        innerBlocks = mlir::DenseI64ArrayAttr::get(
-            getContext(), getInnerBlockSizes<Store>(
-                              op.getOperation(), elemTy, tileTy.getShape()[0],
-                              tileTy.getShape()[1], this->uArchInterface));
+    llvm::SmallVector<mlir::Value> newResults;
+    for (auto [arg1, arg2] :
+         llvm::zip_equal(op.getResults(), adaptor.getResults())) {
+      auto block = analysis.getDefBlockSize(arg1);
+      if (mlir::isa<mlir::VectorType>(arg1.getType()) && block) {
+        auto pack = addPackOp(arg2, block.asArrayRef(), rewriter);
+        newResults.push_back(pack);
       } else {
-        return rewriter.notifyMatchFailure(
-            op,
-            "The tile is used for multiple purpose. The init-duplicate pass "
-            "should be run first to resolve this issue.");
+        newResults.push_back(arg2);
       }
     }
 
-    if (innerBlocks.empty()) {
-      op->emitOpError() << "Invalid inner block sizes ";
-      return mlir::failure();
-    }
-
-    auto attr = imex::xetile::XeTileAttr::get(
-        op.getContext(), tileTy.getSgMap(), tileTy.getWgMap(),
-        tileTy.getOrder(), innerBlocks, tileTy.getMemorySpace());
-
-    auto newTileTy =
-        imex::xetile::TileType::get(tileTy.getShape(), elemTy, attr);
-
-    rewriter.startOpModification(op);
-    op.getTile().setType(newTileTy);
-    rewriter.finalizeOpModification(op);
-
-    return mlir::success();
-  }
-};
-
-// It updates load_tile to reveal effects of innerblock attribute by
-// representing value as 4D vector. An unpack op is added at the end
-// to make this change to be transparent to its users.
-struct LoadTileOpPattern
-    : public XeTileConversion<xetile::LoadTileOp, TileUsageAnalysis> {
-
-  using XeTileConversion<xetile::LoadTileOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  LoadTileOpPattern(mlir::MLIRContext *context,
-                    imex::XeTypeConverter &converter,
-                    TileUsageAnalysis &analysis,
-                    std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
-
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::LoadTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tileTy = op.getSource().getType();
-    auto shape = tileTy.getShape();
-    auto innerBlocks = tileTy.getInnerBlocks();
-    auto rank = op.getValue().getType().getRank();
-
-    if (!innerBlocks || rank == 4)
-      return rewriter.notifyMatchFailure(
-          op, "Input is not updated or the op has been updated.\n");
-
-    auto vecTy = ::mlir::VectorType::get({shape[0] / innerBlocks[0],
-                                          shape[1] / innerBlocks[1],
-                                          innerBlocks[0], innerBlocks[1]},
-                                         tileTy.getElementType());
-
-    rewriter.startOpModification(op);
-    op.getValue().setType(vecTy);
-    rewriter.finalizeOpModification(op);
-    mlir::OpBuilder::InsertionGuard g(rewriter);
-    rewriter.setInsertionPointAfter(op);
-    auto unpack = addUnpackOp(op, rewriter);
-    rewriter.replaceAllUsesExcept(op, unpack, unpack);
-
+    auto newOp = rewriter.create<mlir::scf::YieldOp>(op.getLoc(), newResults);
+    rewriter.replaceOp(op, newOp);
     return mlir::success();
   }
 };
 
-// It updates store_tile to reveal effects of innerblock attribute.
-// It uses pack op to align the shape of its vector value to the tile shape.
-struct StoreTileOpPattern
-    : public XeTileConversion<xetile::StoreTileOp, TileUsageAnalysis> {
-
-  using XeTileConversion<xetile::StoreTileOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  StoreTileOpPattern(mlir::MLIRContext *context,
-                     imex::XeTypeConverter &converter,
-                     TileUsageAnalysis &analysis,
-                     std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
+// Blocks a vector.create_mask op such that, ideally, it matches its consuming
+// select op (which is an elementwise op). In this way, during the lowering to
+// XeGPU, there will be a one-to-one correspondence and an
+// unrealized_conversion_cast will not be needed.
+struct VectorCreateMaskOpPattern
+    : public OpConversionPatternWithAnalysis<mlir::vector::CreateMaskOp,
+                                             BlockingAnalysis> {
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+  using OpConversionPatternWithAnalysis<
+      mlir::vector::CreateMaskOp,
+      BlockingAnalysis>::OpConversionPatternWithAnalysis;
 
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::StoreTileOp op, OpAdaptor adaptor,
+  mlir::LogicalResult
+  matchAndRewrite(mlir::vector::CreateMaskOp op, OpAdaptor adaptor,
                   OpPatternRewriter &rewriter) const override {
-    auto tileTy = llvm::dyn_cast<xetile::TileType>(adaptor.getTile().getType());
-    auto innerBlocks = tileTy.getInnerBlocks();
-    auto value = adaptor.getValue();
-    auto valTy = mlir::dyn_cast<mlir::VectorType>(value.getType());
+    auto res = op.getResult();
+    auto resType = res.getType();
+    if (resType.getRank() != 2)
+      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
 
-    // its inputs has not been updated yet.
-    if (innerBlocks && valTy.getRank() == 2) {
-      value = addPackOp(value, innerBlocks.asArrayRef(), rewriter);
-      rewriter.replaceOpWithNewOp<xetile::StoreTileOp>(op, value,
-                                                       adaptor.getTile());
-      return mlir::success();
+    // Only two cases are supported for now:
+    // 1.The first operand is a constant equal to the first dimension of the
+    // output shape (i.e., all rows are enabled). In other words, masking
+    // columns within a row is supported.
+    // 2.The second operand is a constant equal to the second dimension of the
+    // output shape (i.e., all columns are enabled).
+    auto shape = resType.getShape();
+    APInt cstOp0, cstOp1;
+    if (!(matchPattern(op->getOperand(0), m_ConstantInt(&cstOp0)) &&
+          cstOp0.getSExtValue() == shape[0]) &&
+        !(matchPattern(op->getOperand(1), m_ConstantInt(&cstOp1)) &&
+          cstOp1.getSExtValue() == shape[1])) {
+      op->emitOpError() << "Unsupported operands";
+      return mlir::failure();
     }
-    return mlir::failure();
-  }
-};
-
-// It updates tile_mma to reveal effects of innerblock attribute.
-// Values will be reprented as 4D vectors. An unpack op is applied
-// to its result to make the change transparent to its users.
-struct TileMMAOpPattern
-    : public XeTileConversion<xetile::TileMMAOp, TileUsageAnalysis> {
-
-  using XeTileConversion<xetile::TileMMAOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  TileMMAOpPattern(mlir::MLIRContext *context, imex::XeTypeConverter &converter,
-                   TileUsageAnalysis &analysis,
-                   std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
-
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::TileMMAOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto resultTy = op.getResult().getType();
-    if (resultTy.getRank() != 2)
-      return rewriter.notifyMatchFailure(
-          op, "The result of tile_mma must be 2D vector.\n");
-
-    auto a = adaptor.getA();
-    auto b = adaptor.getB();
-    auto c = adaptor.getC();
-
-    assert(a && b && "a operand or b operand is (are) missing.\n");
-
-    // expecting a, b, c are either 2D vectors defined by UnpackOp or 4D vectors
-    // when its operands has been processed. Otherwise, inputs has not been
-    // fully processed and it is not the right time to update the tile_mma op.
-    if ((!a.getDefiningOp<xetile::TileUnpackOp>() &&
-         mlir::cast<VectorType>(a.getType()).getRank() != 4) ||
-        (!b.getDefiningOp<xetile::TileUnpackOp>() &&
-         mlir::cast<VectorType>(b.getType()).getRank() != 4) ||
-        (c && !c.getDefiningOp<xetile::TileUnpackOp>() &&
-         mlir::cast<VectorType>(c.getType()).getRank() != 4))
-      return rewriter.notifyMatchFailure(
-          op, "expecting a, b, and c are either 2D vectors defined by "
-              "unpackOps or 4D vectors.\n");
-
-    unsigned int CPrecision = resultTy.getElementType().getIntOrFloatBitWidth();
-    if (c)
-      CPrecision = op.getC().getType().getElementType().getIntOrFloatBitWidth();
-
-    auto mmaSize = getMMASize(
-        op.getElementType(),
-        op.getAType().getElementType().getIntOrFloatBitWidth(),
-        op.getBType().getElementType().getIntOrFloatBitWidth(), CPrecision,
-        op.getResult().getType().getElementType().getIntOrFloatBitWidth(),
-        this->uArchInterface);
-
-    // packing a, b, c accordingly to with the expected innerblock size.
-    // if they are defined by unpackOps, packOps are added, if they are
-    // 4D vectors, pairs of unpack and pack ops are added.
-    auto packing = [&](mlir::Value val, llvm::ArrayRef<int64_t> shape,
-                       OpPatternRewriter &rewriter) -> mlir::Value {
-      if (val.getDefiningOp<xetile::TileUnpackOp>())
-        return addPackOp(val, shape, rewriter);
-      return addUnpackAndPackOps(val, shape, rewriter);
-    };
-    a = packing(a, {mmaSize[0], mmaSize[1]}, rewriter);
-    b = packing(b, {mmaSize[1], mmaSize[2]}, rewriter);
-    if (c)
-      c = packing(c, {mmaSize[0], mmaSize[2]}, rewriter);
-
-    assert(mlir::dyn_cast<VectorType>(a.getType()).getRank() == 4 &&
-           mlir::dyn_cast<VectorType>(b.getType()).getRank() == 4 &&
-           (!c || mlir::dyn_cast<VectorType>(c.getType()).getRank() == 4) &&
-           "a, b and c (if has) should be transformed into 4D vectors.\n");
-
-    auto shape = resultTy.getShape();
-    auto vecTy = ::mlir::VectorType::get(
-        {shape[0] / mmaSize[0], shape[1] / mmaSize[2], mmaSize[0], mmaSize[2]},
-        resultTy.getElementType());
-
-    mlir::Value newOp = rewriter.create<imex::xetile::TileMMAOp>(
-        op.getLoc(), vecTy, a, b, c, nullptr, nullptr, nullptr);
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-// It updates update_tile_offset to reveal effects of innerblock attribute
-// by updating the type of it result.
-struct UpdateTileOffsetOpPattern
-    : public XeTileConversion<xetile::UpdateTileOffsetOp, TileUsageAnalysis> {
-
-  using XeTileConversion<xetile::UpdateTileOffsetOp,
-                         TileUsageAnalysis>::XeTileConversion;
-
-  UpdateTileOffsetOpPattern(mlir::MLIRContext *context,
-                            imex::XeTypeConverter &converter,
-                            TileUsageAnalysis &analysis,
-                            std::shared_ptr<XeuArchInterface> ptruArch)
-      : XeTileConversion(context, converter, analysis) {
-    this->uArchInterface = ptruArch;
-  }
 
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
+    auto block = analysis.getDefBlockSize(res);
+    if (!block)
+      return rewriter.notifyMatchFailure(op, "Invalid block size.");
 
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::UpdateTileOffsetOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    if (adaptor.getTile().getType() == op.getResult().getType())
+    // TODO: support blocking the outer dimension.
+    if (block[0] != 1) {
+      op->emitOpError() << "Unsupported inner block sizes";
       return mlir::failure();
+    }
 
-    rewriter.replaceOpWithNewOp<xetile::UpdateTileOffsetOp>(
-        op, adaptor.getTile().getType(), adaptor.getTile(),
-        adaptor.getOffsetX(), adaptor.getOffsetY());
+    auto newTy = mlir::VectorType::get(
+        {shape[0] / block[0], shape[1] / block[1], block[0], block[1]},
+        resType.getElementType());
+
+    // Due to the simplifications mentioned above, for now, the index operands
+    // are not adjusted. In fact, only the first index operand (masked rows) or
+    // the second index operand (masked columns) will be used during the
+    // lowering to XeGPU.
+    auto operands = op.getOperands();
+    auto newOp = rewriter.create<mlir::vector::CreateMaskOp>(
+        op.getLoc(), newTy,
+        ValueRange({operands[0], operands[1], operands[0], operands[1]}),
+        op->getAttrs());
+    auto unpack = addUnpackOp(newOp, rewriter);
+    rewriter.replaceOp(op, unpack);
     return mlir::success();
   }
 };
 
-void populateXeTileBlockingPatterns(
-    imex::XeTypeConverter &converter, mlir::RewritePatternSet &patterns,
-    TileUsageAnalysis &analysis, std::shared_ptr<XeuArchInterface> ptruArch) {
-  patterns.insert<ArithConstantOpPattern, VectorCreateMaskOpPattern,
-                  VectorizableOpPattern, SCFForOpPattern, SCFYieldOpPattern,
-                  InitTileOpPattern, LoadTileOpPattern, StoreTileOpPattern,
-                  TileMMAOpPattern, UpdateTileOffsetOpPattern,
-                  VectorMultiDimReductionOpPattern, TileReductionOpPattern,
-                  TileBroadcastOpPattern>(patterns.getContext(), converter,
-                                          analysis, ptruArch);
-  patterns.insert<TransposeOpPattern<mlir::vector::TransposeOp>,
-                  TransposeOpPattern<xetile::TransposeOp>>(
-      patterns.getContext(), converter, analysis, ptruArch);
+} // namespace Blocking
+
+void populateXeTileBlockingPatterns(mlir::RewritePatternSet &patterns,
+                                    BlockingAnalysis &analysis) {
+  patterns.insert<
+      Blocking::ArithConstantOpPattern, Blocking::InitTileOpPattern,
+      Blocking::PrefetchTileOpPattern, Blocking::LoadTileOpPattern,
+      Blocking::StoreTileOpPattern, Blocking::UpdateTileOffsetOpPattern,
+      Blocking::TileMMAOpPattern, Blocking::TileReductionOpPattern,
+      Blocking::TileBroadcastOpPattern, Blocking::TileTransposeOpPattern,
+      Blocking::VectorizableOpPattern, Blocking::SCFForOpPattern,
+      Blocking::SCFYieldOpPattern, Blocking::VectorCreateMaskOpPattern>(
+      patterns.getContext(), analysis);
 }
 
 // Lowers XeTile to blocked layout with high-dim vector
 class XeTileBlockingPass : public impl::XeTileBlockingBase<XeTileBlockingPass> {
 
 public:
-  XeTileBlockingPass() = default;
+  XeTileBlockingPass() {
+    uArchInterface = std::make_shared<imex::XePVCuArch>();
+  }
 
   XeTileBlockingPass(const std::string &deviceName) {
-    if (this->device.getNumOccurrences() == 0) {
-      this->device = deviceName;
-
-      if (deviceName == "pvc") {
-        uArchInterface = std::make_shared<XePVCuArch>();
-      }
+    if (deviceName == "pvc") {
+      uArchInterface = std::make_shared<imex::XePVCuArch>();
     }
   }
 
+  mlir::LogicalResult
+  initializeOptions(mlir::StringRef options,
+                    mlir::function_ref<mlir::LogicalResult(const llvm::Twine &)>
+                        errorHandler) override {
+    if (failed(Pass::initializeOptions(options, errorHandler)))
+      return mlir::failure();
+    if (device == "pvc")
+      uArchInterface = std::make_shared<imex::XePVCuArch>();
+    else
+      return errorHandler(llvm::Twine("Invalid device: ") + device);
+    return mlir::success();
+  }
+
   void runOnOperation() override {
-    mlir::MLIRContext &context = getContext();
     auto mod = this->getOperation();
-
     // skip functions with XeTile.TileType inputs and outputs
     if (!isSupportedModule(mod)) {
       mod.emitOpError(
@@ -1219,33 +876,81 @@ class XeTileBlockingPass : public impl::XeTileBlockingBase<XeTileBlockingPass> {
       return signalPassFailure();
     }
 
-    XeTypeConverter typeConverter(context);
-    mlir::RewritePatternSet patterns(&context);
+    BlockingAnalysis analysis(uArchInterface);
+    if (mlir::failed(analysis.run(mod)))
+      return signalPassFailure();
+
+    // analysis.printAnalysisResult();
+
+    mlir::MLIRContext &context = getContext();
 
-    // Use TopDown traversal order, and only look at existing ops
-    // to simpliy the code logic and speedup the pass
-    mlir::GreedyRewriteConfig config;
-    config.enableRegionSimplification = GreedySimplifyRegionLevel::Disabled;
-    config.useTopDownTraversal = true;
-    config.strictMode = GreedyRewriteStrictness::ExistingAndNewOps;
-    { // initialize the inner block size per op.
-      patterns.clear();
-      auto &analysis = getAnalysis<TileUsageAnalysis>();
-      populateXeTileBlockingPatterns(typeConverter, patterns, analysis,
-                                     uArchInterface);
-      if (failed(
-              applyPatternsAndFoldGreedily(mod, std::move(patterns), config))) {
-        return signalPassFailure();
+    mlir::RewritePatternSet patterns(&context);
+    populateXeTileBlockingPatterns(patterns, analysis);
+
+    mlir::ConversionTarget target(context);
+    target.addLegalOp<xetile::TilePackOp>();
+    target.addLegalOp<xetile::TileUnpackOp>();
+    target.addLegalOp<mlir::func::ReturnOp>();
+    target.addLegalOp<mlir::vector::ShapeCastOp>();
+    target.addLegalOp<mlir::vector::StoreOp>();
+    target.addLegalOp<mlir::vector::LoadOp>();
+
+    target.addDynamicallyLegalOp<mlir::arith::ConstantOp>(
+        [&](mlir::arith::ConstantOp op) -> bool {
+          auto vecTy = mlir::dyn_cast<mlir::VectorType>(op.getType());
+          return (!vecTy || vecTy.getRank() != 2);
+        });
+
+    target.addDynamicallyLegalOp<xetile::InitTileOp>(
+        [&](xetile::InitTileOp op) -> bool {
+          return (op && op.getTile().getType().getInnerBlocks());
+        });
+
+    target.addDynamicallyLegalOp<xetile::PrefetchTileOp>(
+        [&](xetile::PrefetchTileOp op) -> bool {
+          return (op && op.getTile().getType().getInnerBlocks());
+        });
+
+    target.addDynamicallyLegalOp<xetile::UpdateTileOffsetOp>(
+        [&](xetile::UpdateTileOffsetOp op) -> bool {
+          return (op && op.getTile().getType().getInnerBlocks());
+        });
+
+    target.addDynamicallyLegalOp<xetile::LoadTileOp>(
+        [&](xetile::LoadTileOp op) -> bool {
+          return (op && op.getValue().getType().getRank() == 4);
+        });
+
+    target.addDynamicallyLegalOp<xetile::StoreTileOp>(
+        [&](xetile::StoreTileOp op) -> bool {
+          return (op && op.getValue().getType().getRank() == 4);
+        });
+
+    target.addDynamicallyLegalOp<xetile::TileMMAOp>(
+        [&](xetile::TileMMAOp op) -> bool {
+          return (op && op.getOutput().getType().getRank() == 4);
+        });
+
+    target.markUnknownOpDynamicallyLegal([&](mlir::Operation *op) {
+      bool result = true;
+      for (auto ty : op->getOperandTypes()) {
+        if (auto vecTy = mlir::dyn_cast<mlir::VectorType>(ty))
+          result &= (vecTy.getRank() != 2);
+        if (auto tileTy = mlir::dyn_cast<xetile::TileType>(ty))
+          result &= bool(tileTy.getInnerBlocks());
       }
-    }
-    { // aligning the inner block size among tile_mma and load_tile.
-      patterns.clear();
-      auto &analysis = getAnalysis<PropagateAnalysis>();
-      populateXeTileBlockAligningPatterns(typeConverter, patterns, analysis);
-      if (failed(
-              applyPatternsAndFoldGreedily(mod, std::move(patterns), config))) {
-        return signalPassFailure();
+      for (auto ty : op->getResultTypes()) {
+        if (auto vecTy = mlir::dyn_cast<mlir::VectorType>(ty))
+          result &= (vecTy.getRank() != 2);
+        if (auto tileTy = mlir::dyn_cast<xetile::TileType>(ty))
+          result &= bool(tileTy.getInnerBlocks());
       }
+      return result;
+    });
+
+    auto status = applyPartialConversion(mod, target, std::move(patterns));
+    if (failed(status)) {
+      return signalPassFailure();
     }
   }
 
diff --git a/lib/Dialect/XeTile/Transforms/BlockingAnalysis.cpp b/lib/Dialect/XeTile/Transforms/BlockingAnalysis.cpp
index 2005f185c..fad3acd18 100644
--- a/lib/Dialect/XeTile/Transforms/BlockingAnalysis.cpp
+++ b/lib/Dialect/XeTile/Transforms/BlockingAnalysis.cpp
@@ -2,7 +2,7 @@
 #include <llvm/ADT/DenseSet.h>
 #include <llvm/Support/Debug.h>
 
-#include "BlockingAnalysis.h"
+#include "imex/Dialect/XeTile/Transforms/BlockingAnalysis.h"
 
 namespace llvm {
 using imex::Block;
@@ -121,8 +121,9 @@ BlockingRequests::BlockingRequests(Block block, UsePoint point) {
 Block BlockingRequests::getDefBlock() const {
   if (def)
     return def;
-  if (requests.size())
-    return (requests.begin()->second);
+  for (auto [p, req] : requests)
+    if (req)
+      return req;
   return Block();
 }
 
@@ -514,18 +515,19 @@ void BlockingAnalysisImpl::visitTransposeOp(
 
   auto lattice = results[0]->getValue();
 
-  // Wait for requests from users.
-  if (!op->use_empty() && !lattice.isInitialized())
-    return;
+  // Wait for requests from users, unless all users are terminators
+  if (!op->use_empty() && !lattice.isInitialized()) {
+    for (auto user : op->getUsers()) {
+      if (!user->hasTrait<mlir::OpTrait::ReturnLike>())
+        return;
+    }
+  }
 
-  Block block;
   auto srcTy = op.getVector().getType();
   auto shape = srcTy.getShape();
 
-  // use the default size if no users
-  if (op->use_empty()) {
-    block = getInnerBlockSize(op, srcTy.getElementType(), shape);
-  }
+  // init with the default size
+  Block block = getInnerBlockSize(op, srcTy.getElementType(), shape);
 
   // TransposeOp determines its blocking size based on requests from
   // its users, by swapping the blocking size of its users.
@@ -566,17 +568,30 @@ void BlockingAnalysisImpl::visitVectorizableOp(
 
   auto lattice = results[0]->getValue();
 
-  // Wait for requests from users.
-  if (!op->use_empty() && !lattice.isInitialized())
-    return;
-
   auto elemTy = type.getElementType();
   auto shape = type.getShape();
   Block block = getInnerBlockSize(op, elemTy, shape);
 
+  // Wait for requests from users, unless all of its users are terminators.
+  if (!op->use_empty() && !lattice.isInitialized()) {
+    for (auto user : op->getUsers()) {
+      if (!user->hasTrait<mlir::OpTrait::ReturnLike>())
+        return;
+    }
+  }
+
+  // TODO: special hack is needed for select op, becasue mismatch with
+  // creat_mask will generate vector shuffles on i1 type, which is not
+  // well supported by IGC yet. Using default size (same as CreateMask)
+  // could help to avoid this. Remove it when lowering of create_mask
+  // and IGC get matured.
+  if (mlir::isa<mlir::arith::SelectOp>(op)) {
+    block = Block(1, block[1]);
+  }
+
   // elementwise operations are not sensitive to the block size.
-  // It will use the block size requested by its users.
-  if (lattice.isInitialized()) {
+  // It will use the block size requested by its users, except SelectOp
+  if (lattice.isInitialized() && !mlir::isa<mlir::arith::SelectOp>(op)) {
     block[0] = 0;
     for (auto &req : lattice.getRequests()) {
       block[0] = std::max(block[0], req[0]);
diff --git a/lib/Dialect/XeTile/Transforms/BlockingRewrite.cpp b/lib/Dialect/XeTile/Transforms/BlockingRewrite.cpp
deleted file mode 100644
index 878987bdc..000000000
--- a/lib/Dialect/XeTile/Transforms/BlockingRewrite.cpp
+++ /dev/null
@@ -1,960 +0,0 @@
-//===-------------- Blocking.cpp --------- Blocking Pass  -------*- C++ -*-===//
-//
-// Copyright 2024 Intel Corporation
-// Part of the IMEX Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file contains lowering transformation for determing the problem size
-/// that can be handled by an XeGPU operator (hardware instruction). XeTile
-/// program can work one bigger problem size that cannot be handled by a
-/// hardware instruction. But it needs to be decomposed into smaller pieces
-/// such that each pieces can be handled by a hardware instruction.
-///
-//===----------------------------------------------------------------------===//
-#include <mlir/Analysis/DataFlow/ConstantPropagationAnalysis.h>
-#include <mlir/Analysis/DataFlow/DeadCodeAnalysis.h>
-#include <mlir/Analysis/DataFlow/SparseAnalysis.h>
-#include <mlir/Conversion/LLVMCommon/TypeConverter.h>
-#include <mlir/Dialect/Arith/IR/Arith.h>
-#include <mlir/Dialect/Func/IR/FuncOps.h>
-#include <mlir/Dialect/GPU/IR/GPUDialect.h>
-#include <mlir/Dialect/Index/IR/IndexDialect.h>
-#include <mlir/Dialect/Linalg/IR/Linalg.h>
-#include <mlir/Dialect/Linalg/Utils/Utils.h>
-#include <mlir/Dialect/Math/IR/Math.h>
-#include <mlir/Dialect/MemRef/IR/MemRef.h>
-#include <mlir/Dialect/SCF/IR/SCF.h>
-#include <mlir/IR/BuiltinAttributes.h>
-#include <mlir/IR/BuiltinTypes.h>
-#include <mlir/IR/PatternMatch.h>
-#include <mlir/Pass/Pass.h>
-#include <mlir/Support/LogicalResult.h>
-#include <mlir/Transforms/DialectConversion.h>
-#include <mlir/Transforms/GreedyPatternRewriteDriver.h>
-
-#include <llvm/ADT/DenseMapInfo.h>
-#include <llvm/ADT/STLExtras.h>
-#include <llvm/ADT/SetVector.h>
-#include <llvm/ADT/SmallVector.h>
-#include <llvm/Support/Debug.h>
-
-#include <algorithm>
-#include <optional>
-#include <set>
-#include <tuple>
-
-#include "imex/Dialect/XeTile/Transforms/Passes.h"
-#include "imex/Utils/DebugUtils.h"
-#include "imex/Utils/XeArch.h"
-
-#include "BlockingAnalysis.h"
-
-using namespace mlir;
-using namespace llvm;
-using namespace imex;
-namespace imex {
-#define GEN_PASS_DEF_NEWXETILEBLOCKING
-#include "imex/Dialect/XeTile/Transforms/Passes.h.inc"
-} // namespace imex
-
-namespace imex {
-namespace Blocking {
-
-static xetile::TileUnpackOp
-addUnpackOp(mlir::Value src, mlir::ConversionPatternRewriter &rewriter) {
-  auto srcTy = llvm::dyn_cast_if_present<mlir::VectorType>(src.getType());
-  assert(srcTy && srcTy.getRank() == 4);
-  auto shape = srcTy.getShape();
-  auto grids = shape.take_front(2);
-  auto innerBlocks = shape.take_back(2);
-  llvm::SmallVector<int64_t> unpackShape(
-      {grids[0] * innerBlocks[0], grids[1] * innerBlocks[1]});
-
-  auto unpackTy = mlir::VectorType::get(unpackShape, srcTy.getElementType());
-  return rewriter.create<xetile::TileUnpackOp>(
-      src.getLoc(), unpackTy, src,
-      mlir::DenseI64ArrayAttr::get(src.getContext(), innerBlocks));
-}
-
-static mlir::Value addPackOp(mlir::Value src,
-                             llvm::ArrayRef<int64_t> targetBlkSizes,
-                             mlir::ConversionPatternRewriter &rewriter) {
-  auto srcTy = mlir::dyn_cast<mlir::VectorType>(src.getType());
-  assert(srcTy && targetBlkSizes.size() == 2);
-  auto shape = srcTy.getShape();
-  llvm::SmallVector<int64_t> packShape({shape[0] / targetBlkSizes[0],
-                                        shape[1] / targetBlkSizes[1],
-                                        targetBlkSizes[0], targetBlkSizes[1]});
-
-  auto packTy = mlir::VectorType::get(packShape, srcTy.getElementType());
-  auto packOp = rewriter.create<xetile::TilePackOp>(
-      src.getLoc(), packTy, src,
-      mlir::DenseI64ArrayAttr::get(src.getContext(), targetBlkSizes));
-  return packOp;
-}
-
-/// OpConversionPatternWithAnalysis is a wrapper around OpConversionPattern
-/// but takes an extra AnalysisT object as an argument, such that patterns
-/// can leverage the analysis results.
-template <typename SourceOp, typename AnalysisT>
-class OpConversionPatternWithAnalysis
-    : public mlir::OpConversionPattern<SourceOp> {
-public:
-  using OpPatternRewriter = typename mlir::ConversionPatternRewriter;
-
-  OpConversionPatternWithAnalysis(mlir::MLIRContext *context,
-                                  AnalysisT &analysis)
-      : mlir::OpConversionPattern<SourceOp>(context), analysis(analysis) {}
-
-protected:
-  AnalysisT &analysis;
-};
-
-/// OpTraitConversionPatternWithAnalysis is a wrapper around
-/// OpTraitConversionPattern but takes an extra AnalysisT object as an argument,
-/// such that patterns can leverage the analysis results.
-template <template <typename> class TraitType, typename AnalysisT>
-class OpTraitConversionPatternWithAnalysis
-    : public mlir::OpTraitConversionPattern<TraitType> {
-public:
-  OpTraitConversionPatternWithAnalysis(mlir::MLIRContext *context,
-                                       AnalysisT &analysis,
-                                       PatternBenefit benefit = 1)
-      : mlir::OpTraitConversionPattern<TraitType>(context, benefit),
-        analysis(analysis) {}
-
-protected:
-  AnalysisT &analysis;
-};
-
-// It blocks/extends a 2D constant dense vector into a
-// 4D vector with the last 2 dim corresponding to block size.
-// which is chosed based on requests from its users.
-// example: arith.constant dense<0.0>: vector<32x32xf16>
-//      --> arith.constant dense<0.0>: vector<4x2x8x16xf16>
-// assuming [8, 16] is the block size.
-struct ArithConstantOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::arith::ConstantOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      mlir::arith::ConstantOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::arith::ConstantOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto value = llvm::dyn_cast<mlir::DenseElementsAttr>(op.getValue());
-
-    // TODO: it maybe unstable to determine whether doing blocking or not
-    //  for a constant op simply based on its 2D shape.
-    if (!value || value.getType().getRank() != 2)
-      return mlir::failure();
-
-    auto blockSize = analysis.getDefBlockSize(op.getResult());
-    if (!blockSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    auto shape = value.getType().getShape();
-    auto newTy =
-        mlir::VectorType::get({shape[0] / blockSize[0], shape[1] / blockSize[1],
-                               blockSize[0], blockSize[1]},
-                              value.getElementType());
-
-    // TODO: it is logically incorrect to reshape a dense value.
-    // it doesn't show the impact of pack effect. It works on some
-    // cases in which all elements has the same value, but not general.
-    value = value.reshape(newTy);
-    auto loc = op.getLoc();
-    auto newOp = rewriter.create<mlir::arith::ConstantOp>(loc, value);
-    auto unpack = addUnpackOp(newOp, rewriter);
-
-    rewriter.replaceOp(op, unpack);
-    return mlir::success();
-  }
-};
-
-// It updates init_tile by attaching innerBlock attribute to the result
-// tile. The block size is choosed based on requests from its users.
-struct InitTileOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::InitTileOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::InitTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::InitTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tileTy = op.getType();
-    auto shape = tileTy.getShape();
-    if (tileTy.getRank() != 2)
-      return rewriter.notifyMatchFailure(
-          op, "Skipped InitTileOp because the result tile is not rank 2.\n");
-
-    auto innerBlockAttr = tileTy.getInnerBlocks();
-
-    // skip it if innerBlocks has been set by user or compiler.
-    if (innerBlockAttr)
-      return mlir::failure();
-
-    auto blockSize = analysis.getDefBlockSize(op.getTile());
-    if (!blockSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    innerBlockAttr =
-        mlir::DenseI64ArrayAttr::get(getContext(), blockSize.asArrayRef());
-
-    if (innerBlockAttr.empty())
-      return rewriter.notifyMatchFailure(op, "Invalid inner block sizes ");
-
-    auto attr = imex::xetile::XeTileAttr::get(
-        op.getContext(), tileTy.getSgMap(), tileTy.getWgMap(),
-        tileTy.getOrder(), innerBlockAttr, tileTy.getMemorySpace());
-
-    auto elemTy = tileTy.getElementType();
-    auto newTileTy = imex::xetile::TileType::get(shape, elemTy, attr);
-
-    auto newOp = rewriter.create<xetile::InitTileOp>(
-        op.getLoc(), mlir::TypeRange({newTileTy}), op->getOperands(),
-        op->getAttrs());
-
-    rewriter.replaceOp(op, newOp);
-
-    return mlir::success();
-  }
-};
-
-// It updates tile operand of prefetch_tile.
-struct PrefetchTileOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::PrefetchTileOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::PrefetchTileOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::PrefetchTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tile = adaptor.getTile();
-    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-    // define op is not updated yet.
-    if (!blockSize)
-      return failure();
-
-    rewriter.startOpModification(op);
-    op->setOperand(0, tile);
-    rewriter.finalizeOpModification(op);
-
-    return mlir::success();
-  }
-};
-
-// It updates load_tile to reveal effects of innerblock attribute by
-// representing value as 4D vector. An unpack op is added at the end
-// to make this change to be transparent to its users.
-struct LoadTileOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::LoadTileOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::LoadTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::LoadTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto source = adaptor.getSource();
-    auto tileTy = mlir::cast<xetile::TileType>(source.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-    auto rank = op.getValue().getType().getRank();
-
-    if (!blockSize || rank == 4)
-      return rewriter.notifyMatchFailure(
-          op, "Input is not updated or the op has been updated.\n");
-
-    auto shape = tileTy.getShape();
-    auto vecTy = ::mlir::VectorType::get({shape[0] / blockSize[0],
-                                          shape[1] / blockSize[1], blockSize[0],
-                                          blockSize[1]},
-                                         tileTy.getElementType());
-    mlir::Value newOp = rewriter.create<xetile::LoadTileOp>(
-        op.getLoc(), vecTy, adaptor.getSource(),
-        op.getPadding().value_or(mlir::Attribute()));
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-// It updates store_tile to reveal effects of innerblock attribute.
-// It uses pack op to align the shape of its vector value to the tile shape.
-struct StoreTileOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::StoreTileOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::StoreTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::StoreTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto value = adaptor.getValue();
-    auto valTy = mlir::dyn_cast<mlir::VectorType>(value.getType());
-    auto tile = adaptor.getTile();
-    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-
-    // its inputs has not been updated yet.
-    if (blockSize && valTy.getRank() == 2) {
-      value = addPackOp(value, blockSize.asArrayRef(), rewriter);
-      rewriter.replaceOpWithNewOp<xetile::StoreTileOp>(op, value, tile);
-      return mlir::success();
-    }
-    return mlir::failure();
-  }
-};
-
-// It updates update_tile_offset to reveal effects of innerblock attribute
-// by updating the type of it result.
-struct UpdateTileOffsetOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::UpdateTileOffsetOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::UpdateTileOffsetOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::UpdateTileOffsetOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tile = adaptor.getTile();
-    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-    // define op is not updated yet.
-    if (!blockSize)
-      return failure();
-
-    rewriter.replaceOpWithNewOp<xetile::UpdateTileOffsetOp>(
-        op, tileTy, tile, adaptor.getOffsetX(), adaptor.getOffsetY());
-    return mlir::success();
-  }
-};
-
-// It updates tile_mma to reveal effects of innerblock attribute.
-// Values will be reprented as 4D vectors. An unpack op is applied
-// to its result to make the change transparent to its users.
-struct TileMMAOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::TileMMAOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::TileMMAOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::TileMMAOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto resultTy = op.getResult().getType();
-    if (resultTy.getRank() != 2)
-      return rewriter.notifyMatchFailure(
-          op, "The result of tile_mma must be 2D vector.\n");
-
-    auto a = adaptor.getA();
-    auto b = adaptor.getB();
-    auto c = adaptor.getC();
-
-    assert(a && b && "a operand or b operand is (are) missing.\n");
-
-    auto getBlockingSize = [&](mlir::Value val,
-                               int pos) -> mlir::FailureOr<Block> {
-      auto blk = analysis.getUseBlockSize(val, UsePoint(op, pos));
-      if (!blk)
-        return rewriter.notifyMatchFailure(op, "Invalid block size.");
-      return blk;
-    };
-
-    auto aBlockSize = getBlockingSize(op.getA(), 0);
-    auto bBlockSize = getBlockingSize(op.getB(), 1);
-    if (mlir::failed(aBlockSize) || mlir::failed(bBlockSize))
-      return mlir::failure();
-    if (c) {
-      auto cBlockSize = getBlockingSize(op.getC(), 2);
-      if (mlir::failed(cBlockSize))
-        return mlir::failure();
-      c = addPackOp(c, cBlockSize->asArrayRef(), rewriter);
-    }
-
-    a = addPackOp(a, aBlockSize->asArrayRef(), rewriter);
-    b = addPackOp(b, bBlockSize->asArrayRef(), rewriter);
-
-    assert(
-        mlir::dyn_cast<mlir::VectorType>(a.getType()).getRank() == 4 &&
-        mlir::dyn_cast<mlir::VectorType>(b.getType()).getRank() == 4 &&
-        (!c || mlir::dyn_cast<mlir::VectorType>(c.getType()).getRank() == 4) &&
-        "a, b and c (if has) should be transformed into 4D vectors.\n");
-
-    Block dBlockSize(aBlockSize->asArrayRef()[0], bBlockSize->asArrayRef()[1]);
-    auto shape = resultTy.getShape();
-    auto vecTy = ::mlir::VectorType::get({shape[0] / dBlockSize[0],
-                                          shape[1] / dBlockSize[1],
-                                          dBlockSize[0], dBlockSize[1]},
-                                         resultTy.getElementType());
-
-    mlir::Value newOp = rewriter.create<imex::xetile::TileMMAOp>(
-        op.getLoc(), vecTy, a, b, c, nullptr, nullptr, nullptr);
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-struct TileReductionOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::ReductionOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::ReductionOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(xetile::ReductionOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto source = op.getSource();
-    auto srcTy = source.getType();
-    auto reductionDims = op.getReductionDims();
-
-    if (srcTy.getRank() != 2 || reductionDims.size() != 1)
-      return rewriter.notifyMatchFailure(
-          op, "source type is not 2D vector or reduction dims are not 1");
-
-    auto blkSize = analysis.getUseBlockSize(source, UsePoint(op, 0));
-    if (!blkSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    // reduction on one dim becomes reduction on two dims after blocking.
-    // For example:
-    // reduce<add>, %e [1]: vector<16x32xf16> to vector<16x1xf16>
-    // will be transformed to
-    // reduce<add>, %e [1, 3]: vector<16x2x1x16xf16> to
-    // vector<16x1x1x1xf16>
-    auto dim = reductionDims[0];
-
-    auto ctx = op.getContext();
-    auto shape = srcTy.getShape();
-    auto newReductionDims = mlir::DenseI64ArrayAttr::get(ctx, {dim, dim + 2});
-    llvm::SmallVector<int64_t> resultShape(
-        {shape[0] / blkSize[0], shape[1] / blkSize[1], blkSize[0], blkSize[1]});
-    for (auto dim : newReductionDims.asArrayRef())
-      resultShape[dim] = 1;
-
-    auto elemTy = srcTy.getElementType();
-    auto resultType = mlir::VectorType::get(resultShape, elemTy);
-
-    auto newSource = addPackOp(source, {blkSize[0], blkSize[1]}, rewriter);
-    mlir::Value newOp = rewriter.create<xetile::ReductionOp>(
-        op.getLoc(), resultType, op.getKind(), newSource, newReductionDims);
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-struct TileBroadcastOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::BroadcastOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::BroadcastOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(xetile::BroadcastOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto loc = op.getLoc();
-    auto src = op.getSource();
-    auto srcTy = src.getType();
-    auto elemTy = srcTy.getElementType();
-    auto broadcastDims = op.getBroadcastDim();
-
-    if (srcTy.getRank() != 2 || broadcastDims.size() != 1)
-      return rewriter.notifyMatchFailure(
-          op, "source type is not 2D vector or rank of broadcastDims is not 1");
-
-    auto srcBlkSize = analysis.getUseBlockSize(src, UsePoint(op, 0));
-    auto resBlkSize = analysis.getDefBlockSize(op.getResult());
-    if (!srcBlkSize || !resBlkSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    auto outShape = op.getResult().getType().getShape();
-
-    // TODO: move this into analysis
-    llvm::SmallVector<int64_t> resultShape(
-        {outShape[0], outShape[1] / resBlkSize[1], 1, resBlkSize[1]});
-
-    auto newSource = addPackOp(adaptor.getSource(),
-                               {srcBlkSize[0], srcBlkSize[1]}, rewriter);
-
-    auto resultType = mlir::VectorType::get(resultShape, elemTy);
-
-    // broadcast on one dim becomes broadcast on two dims after blocking.
-    // For example:
-    // broadcast %a [0]: vector<1x32xf16> to vector<16x32xf16>
-    // will be transformed to
-    // broadcast %a [0, 2]: vector<1x2x1x16xf16> to vector<16x2x1x16xf16>
-    auto dim = broadcastDims[0];
-    auto newBroadcastDims =
-        mlir::DenseI64ArrayAttr::get(op.getContext(), {dim, dim + 2});
-    mlir::Value newOp = rewriter.create<xetile::BroadcastOp>(
-        loc, resultType, newSource, newBroadcastDims);
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-struct TileTransposeOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::TransposeOp,
-                                             BlockingAnalysis> {
-  using OpConversionPatternWithAnalysis<
-      xetile::TransposeOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(xetile::TransposeOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto input = op.getVector();
-    auto inputTy = input.getType();
-    auto result = op.getResult();
-    auto resultTy = result.getType();
-    if (resultTy.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
-
-    auto permutation = op.getPermutation();
-    if (permutation != mlir::ArrayRef<int64_t>({1, 0}))
-      return rewriter.notifyMatchFailure(op, "Unsupported permutation");
-
-    UsePoint p(op, 0);
-    auto inBlockSize = analysis.getUseBlockSize(input, p);
-    auto outBlockSize = analysis.getDefBlockSize(result);
-    if (!inBlockSize || !outBlockSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    auto srcShape = inputTy.getShape();
-    auto newSrcTy = mlir::VectorType::get({srcShape[0] / inBlockSize[0],
-                                           srcShape[1] / inBlockSize[1],
-                                           inBlockSize[0], inBlockSize[1]},
-                                          inputTy.getElementType());
-    auto resShape = resultTy.getShape();
-    auto newDstTy = mlir::VectorType::get({resShape[0] / outBlockSize[0],
-                                           resShape[1] / outBlockSize[1],
-                                           outBlockSize[0], outBlockSize[1]},
-                                          resultTy.getElementType());
-
-    mlir::Value src = adaptor.getVector();
-
-    auto ctxt = op.getContext();
-    auto blockAttr =
-        mlir::DenseI64ArrayAttr::get(ctxt, inBlockSize.asArrayRef());
-    Location loc = op->getLoc();
-    mlir::Value pack =
-        rewriter.create<xetile::TilePackOp>(loc, newSrcTy, src, blockAttr);
-
-    int64_t newPermutation[4] = {1, 0, 3, 2};
-    mlir::Value transpose = rewriter.create<xetile::TransposeOp>(
-        loc, newDstTy, pack, newPermutation);
-
-    blockAttr = mlir::DenseI64ArrayAttr::get(ctxt, outBlockSize.asArrayRef());
-    mlir::Value unpack = rewriter.create<xetile::TileUnpackOp>(
-        loc, resultTy, transpose, blockAttr);
-
-    rewriter.replaceOp(op, unpack);
-
-    return mlir::success();
-  }
-};
-
-struct VectorizableOpPattern
-    : public OpTraitConversionPatternWithAnalysis<mlir::OpTrait::Vectorizable,
-                                                  BlockingAnalysis> {
-
-  using OpTraitConversionPatternWithAnalysis::
-      OpTraitConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::Operation *op, llvm::ArrayRef<mlir::Value> operands,
-                  mlir::ConversionPatternRewriter &rewriter) const override {
-    if (op->getNumResults() != 1)
-      return rewriter.notifyMatchFailure(op, "op must have 1 result");
-
-    auto res = op->getResult(0);
-    auto resType = mlir::dyn_cast<mlir::VectorType>(res.getType());
-    if (!resType || resType.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
-
-    auto blockSize =
-        analysis.getUseBlockSize(op->getOperand(0), UsePoint(op, 0));
-    if (!blockSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    auto shape = resType.getShape();
-    auto elemTy = resType.getElementType();
-    auto blockSizeAttr =
-        mlir::DenseI64ArrayAttr::get(getContext(), blockSize.asArrayRef());
-    int64_t packShape[] = {shape[0] / blockSize[0], shape[1] / blockSize[1],
-                           blockSize[0], blockSize[1]};
-
-    auto newTy = mlir::VectorType::get(packShape, elemTy);
-
-    Location loc = op->getLoc();
-    mlir::OpBuilder::InsertionGuard g(rewriter);
-    llvm::SmallVector<mlir::Value> newOperands;
-    for (auto &&[i, arg] : llvm::enumerate(operands)) {
-      auto argTy = mlir::dyn_cast<mlir::VectorType>(arg.getType());
-      if (!argTy || argTy.getRank() != 2) {
-        newOperands.push_back(arg);
-        continue;
-      }
-      mlir::Value packOp = addPackOp(arg, blockSize.asArrayRef(), rewriter);
-      newOperands.push_back(packOp);
-    }
-
-    mlir::OperationState opState(loc, op->getName(), newOperands,
-                                 mlir::TypeRange(newTy), op->getAttrs(),
-                                 op->getSuccessors());
-
-    auto newOp = rewriter.create(opState);
-    auto unpack = rewriter.create<xetile::TileUnpackOp>(
-        loc, resType, newOp->getResult(0), blockSizeAttr);
-    rewriter.replaceOp(op, unpack);
-    return mlir::success();
-  }
-};
-
-// It rewrites the SCF forOp, it mainly updates the arguments of its
-// region block. unpack ops are added for VectorType operands if needed.
-struct SCFForOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::scf::ForOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      mlir::scf::ForOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(mlir::scf::ForOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    // we don't need to update the forOp if it has no region
-    // iter args, or the region iter args type are not changed.
-    bool changed = false;
-    for (auto [arg1, arg2] :
-         llvm::zip_equal(op.getInitArgs(), adaptor.getInitArgs())) {
-      changed |= (arg1 != arg2);
-    }
-    if (!changed)
-      return mlir::failure();
-
-    // add packOp for vector type operands if needed.
-    llvm::SmallVector<mlir::Value> newInitArgs;
-    for (auto [arg1, arg2] :
-         llvm::zip_equal(op.getRegionIterArgs(), adaptor.getInitArgs())) {
-      auto block = analysis.getDefBlockSize(arg1);
-      if (mlir::isa<mlir::VectorType>(arg1.getType()) && block) {
-        auto pack = addPackOp(arg2, block.asArrayRef(), rewriter);
-        newInitArgs.push_back(pack);
-      } else {
-        newInitArgs.push_back(arg2);
-      }
-    }
-
-    auto newOp = rewriter.create<mlir::scf::ForOp>(
-        op.getLoc(), adaptor.getLowerBound(), adaptor.getUpperBound(),
-        adaptor.getStep(), newInitArgs);
-    mlir::Block *newBlock = newOp.getBody();
-    // remove the terminator of the new block
-    if (newBlock->mightHaveTerminator())
-      rewriter.eraseOp(newBlock->getTerminator());
-
-    auto savedIP = rewriter.saveInsertionPoint();
-    mlir::OpBuilder::InsertionGuard g(rewriter);
-    rewriter.setInsertionPointToStart(newBlock);
-
-    mlir::Block *block = op.getBody();
-
-    // contruct the inputs for the new scf::for block.
-    // An unpackOp is inserted for the corresponding init arg
-    // of the new block if its init value is updated with a pack op.
-    llvm::SmallVector<mlir::Value> newArguments;
-    for (auto [arg1, arg2] :
-         llvm::zip_equal(block->getArguments(), newBlock->getArguments())) {
-      auto block = analysis.getDefBlockSize(arg1);
-      if (mlir::isa<mlir::VectorType>(arg1.getType()) && block) {
-        auto unpack = addUnpackOp(arg2, rewriter);
-        newArguments.push_back(unpack);
-      } else {
-        newArguments.push_back(arg2);
-      }
-    }
-
-    rewriter.restoreInsertionPoint(savedIP);
-    rewriter.mergeBlocks(block, newBlock, newArguments);
-
-    llvm::SmallVector<mlir::Value> newValues;
-    for (auto [i, result] : llvm::enumerate(newOp->getResults())) {
-      // if corresponding init arg is updated with a pack op
-      // an unpack op is needed for the result to make it
-      // transparent to its users.
-      if (newInitArgs[i].getDefiningOp<xetile::TilePackOp>()) {
-        auto unpack = addUnpackOp(result, rewriter);
-        newValues.push_back(unpack);
-      } else {
-        newValues.push_back(result);
-      }
-    }
-    rewriter.replaceOp(op, newValues);
-    return mlir::success();
-  }
-};
-
-// It serves to insert pack ops for approriate vales if needed.
-// for example, tile_mma result is vector<32x32xf16> (after unpack),
-// but its corresponding argument in forOp is with type vector<1x2x32x16xf16>
-// This op pattern will insert a pack op to make it consistent with the
-// corresponding argument type.
-struct SCFYieldOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::scf::YieldOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      mlir::scf::YieldOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(mlir::scf::YieldOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-
-    llvm::SmallVector<mlir::Value> newResults;
-    for (auto [arg1, arg2] :
-         llvm::zip_equal(op.getResults(), adaptor.getResults())) {
-      auto block = analysis.getDefBlockSize(arg1);
-      if (mlir::isa<mlir::VectorType>(arg1.getType()) && block) {
-        auto pack = addPackOp(arg2, block.asArrayRef(), rewriter);
-        newResults.push_back(pack);
-      } else {
-        newResults.push_back(arg2);
-      }
-    }
-
-    auto newOp = rewriter.create<mlir::scf::YieldOp>(op.getLoc(), newResults);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-// Blocks a vector.create_mask op such that, ideally, it matches its consuming
-// select op (which is an elementwise op). In this way, during the lowering to
-// XeGPU, there will be a one-to-one correspondence and an
-// unrealized_conversion_cast will not be needed.
-struct VectorCreateMaskOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::vector::CreateMaskOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      mlir::vector::CreateMaskOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::vector::CreateMaskOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto res = op.getResult();
-    auto resType = res.getType();
-    if (resType.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
-
-    // Only two cases are supported for now:
-    // 1.The first operand is a constant equal to the first dimension of the
-    // output shape (i.e., all rows are enabled). In other words, masking
-    // columns within a row is supported.
-    // 2.The second operand is a constant equal to the second dimension of the
-    // output shape (i.e., all columns are enabled).
-    auto shape = resType.getShape();
-    APInt cstOp0, cstOp1;
-    if (!(matchPattern(op->getOperand(0), m_ConstantInt(&cstOp0)) &&
-          cstOp0.getSExtValue() == shape[0]) &&
-        !(matchPattern(op->getOperand(1), m_ConstantInt(&cstOp1)) &&
-          cstOp1.getSExtValue() == shape[1])) {
-      op->emitOpError() << "Unsupported operands";
-      return mlir::failure();
-    }
-
-    auto block = analysis.getDefBlockSize(res);
-    if (!block)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    // TODO: support blocking the outer dimension.
-    if (block[0] != 1) {
-      op->emitOpError() << "Unsupported inner block sizes";
-      return mlir::failure();
-    }
-
-    auto newTy = mlir::VectorType::get(
-        {shape[0] / block[0], shape[1] / block[1], block[0], block[1]},
-        resType.getElementType());
-
-    // Due to the simplifications mentioned above, for now, the index operands
-    // are not adjusted. In fact, only the first index operand (masked rows) or
-    // the second index operand (masked columns) will be used during the
-    // lowering to XeGPU.
-    auto operands = op.getOperands();
-    auto newOp = rewriter.create<mlir::vector::CreateMaskOp>(
-        op.getLoc(), newTy,
-        ValueRange({operands[0], operands[1], operands[0], operands[1]}),
-        op->getAttrs());
-    auto unpack = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, unpack);
-    return mlir::success();
-  }
-};
-
-} // namespace Blocking
-
-void populateNewXeTileBlockingPatterns(mlir::RewritePatternSet &patterns,
-                                       BlockingAnalysis &analysis) {
-  patterns.insert<
-      Blocking::ArithConstantOpPattern, Blocking::InitTileOpPattern,
-      Blocking::PrefetchTileOpPattern, Blocking::LoadTileOpPattern,
-      Blocking::StoreTileOpPattern, Blocking::UpdateTileOffsetOpPattern,
-      Blocking::TileMMAOpPattern, Blocking::TileReductionOpPattern,
-      Blocking::TileBroadcastOpPattern, Blocking::TileTransposeOpPattern,
-      Blocking::VectorizableOpPattern, Blocking::SCFForOpPattern,
-      Blocking::SCFYieldOpPattern, Blocking::VectorCreateMaskOpPattern>(
-      patterns.getContext(), analysis);
-}
-
-// Lowers XeTile to blocked layout with high-dim vector
-class NewXeTileBlockingPass
-    : public impl::NewXeTileBlockingBase<NewXeTileBlockingPass> {
-
-public:
-  NewXeTileBlockingPass() {
-    uArchInterface = std::make_shared<imex::XePVCuArch>();
-  }
-
-  NewXeTileBlockingPass(const std::string &deviceName) {
-    if (deviceName == "pvc") {
-      uArchInterface = std::make_shared<imex::XePVCuArch>();
-    }
-  }
-
-  mlir::LogicalResult
-  initializeOptions(mlir::StringRef options,
-                    mlir::function_ref<mlir::LogicalResult(const llvm::Twine &)>
-                        errorHandler) override {
-    if (failed(Pass::initializeOptions(options, errorHandler)))
-      return mlir::failure();
-    if (device == "pvc")
-      uArchInterface = std::make_shared<imex::XePVCuArch>();
-    else
-      return errorHandler(llvm::Twine("Invalid device: ") + device);
-    return mlir::success();
-  }
-
-  void runOnOperation() override {
-    auto mod = this->getOperation();
-    // skip functions with XeTile.TileType inputs and outputs
-    if (!isSupportedModule(mod)) {
-      mod.emitOpError(
-          "Currently FunctionType with xetile.TileType is not supported.");
-      return signalPassFailure();
-    }
-
-    if (!uArchInterface) {
-      mod.emitOpError("Can not get GPU Arch Definition for given Arch param");
-      return signalPassFailure();
-    }
-
-    BlockingAnalysis analysis(uArchInterface);
-    if (mlir::failed(analysis.run(mod)))
-      return signalPassFailure();
-
-    // analysis.printAnalysisResult();
-
-    mlir::MLIRContext &context = getContext();
-
-    mlir::RewritePatternSet patterns(&context);
-    populateNewXeTileBlockingPatterns(patterns, analysis);
-
-    mlir::ConversionTarget target(context);
-    target.addLegalOp<xetile::TilePackOp>();
-    target.addLegalOp<xetile::TileUnpackOp>();
-    target.addLegalOp<mlir::vector::ShapeCastOp>();
-    target.addLegalOp<mlir::vector::StoreOp>();
-    target.addLegalOp<mlir::vector::LoadOp>();
-
-    target.addDynamicallyLegalOp<mlir::arith::ConstantOp>(
-        [&](mlir::arith::ConstantOp op) -> bool {
-          auto vecTy = mlir::dyn_cast<mlir::VectorType>(op.getType());
-          return (!vecTy || vecTy.getRank() != 2);
-        });
-
-    target.addDynamicallyLegalOp<xetile::InitTileOp>(
-        [&](xetile::InitTileOp op) -> bool {
-          return (op && op.getTile().getType().getInnerBlocks());
-        });
-
-    target.addDynamicallyLegalOp<xetile::PrefetchTileOp>(
-        [&](xetile::PrefetchTileOp op) -> bool {
-          return (op && op.getTile().getType().getInnerBlocks());
-        });
-
-    target.addDynamicallyLegalOp<xetile::UpdateTileOffsetOp>(
-        [&](xetile::UpdateTileOffsetOp op) -> bool {
-          return (op && op.getTile().getType().getInnerBlocks());
-        });
-
-    target.addDynamicallyLegalOp<xetile::LoadTileOp>(
-        [&](xetile::LoadTileOp op) -> bool {
-          return (op && op.getValue().getType().getRank() == 4);
-        });
-
-    target.addDynamicallyLegalOp<xetile::StoreTileOp>(
-        [&](xetile::StoreTileOp op) -> bool {
-          return (op && op.getValue().getType().getRank() == 4);
-        });
-
-    target.addDynamicallyLegalOp<xetile::TileMMAOp>(
-        [&](xetile::TileMMAOp op) -> bool {
-          return (op && op.getOutput().getType().getRank() == 4);
-        });
-
-    target.markUnknownOpDynamicallyLegal([&](mlir::Operation *op) {
-      bool result = true;
-      for (auto ty : op->getOperandTypes()) {
-        if (auto vecTy = mlir::dyn_cast<mlir::VectorType>(ty))
-          result &= (vecTy.getRank() != 2);
-        if (auto tileTy = mlir::dyn_cast<xetile::TileType>(ty))
-          result &= bool(tileTy.getInnerBlocks());
-      }
-      for (auto ty : op->getResultTypes()) {
-        if (auto vecTy = mlir::dyn_cast<mlir::VectorType>(ty))
-          result &= (vecTy.getRank() != 2);
-        if (auto tileTy = mlir::dyn_cast<xetile::TileType>(ty))
-          result &= bool(tileTy.getInnerBlocks());
-      }
-      return result;
-    });
-
-    auto status = applyPartialConversion(mod, target, std::move(patterns));
-    if (failed(status)) {
-      return signalPassFailure();
-    }
-  }
-
-private:
-  std::shared_ptr<XeuArchInterface> uArchInterface = nullptr;
-};
-
-/// Create a pass
-std::unique_ptr<::mlir::Pass>
-createNewXeTileBlockingPass(const std::string &deviceName) {
-  return std::make_unique<NewXeTileBlockingPass>(deviceName);
-}
-} // namespace imex
diff --git a/lib/Dialect/XeTile/Transforms/CMakeLists.txt b/lib/Dialect/XeTile/Transforms/CMakeLists.txt
index ebcb38c9b..1200e28fc 100644
--- a/lib/Dialect/XeTile/Transforms/CMakeLists.txt
+++ b/lib/Dialect/XeTile/Transforms/CMakeLists.txt
@@ -1,8 +1,6 @@
 add_imex_dialect_library(IMEXXeTileTransforms
-  BlockAligning.cpp
   Blocking.cpp
   BlockingAnalysis.cpp
-  BlockingRewrite.cpp
   InitDuplicate.cpp
   Canonicalization.cpp
   WgToSg.cpp
diff --git a/lib/Dialect/XeTile/Transforms/InitDuplicate.cpp b/lib/Dialect/XeTile/Transforms/InitDuplicate.cpp
index a3d14c9bc..86615ec8f 100644
--- a/lib/Dialect/XeTile/Transforms/InitDuplicate.cpp
+++ b/lib/Dialect/XeTile/Transforms/InitDuplicate.cpp
@@ -37,7 +37,6 @@
 
 #include <optional>
 
-#include "imex/Dialect/XeTile/Transforms/Blocking.h"
 #include "imex/Dialect/XeTile/Transforms/Passes.h"
 #include "imex/Utils/DebugUtils.h"
 
diff --git a/lib/Dialect/XeTile/Transforms/WgToSg.cpp b/lib/Dialect/XeTile/Transforms/WgToSg.cpp
index 417252c32..29da1e01f 100644
--- a/lib/Dialect/XeTile/Transforms/WgToSg.cpp
+++ b/lib/Dialect/XeTile/Transforms/WgToSg.cpp
@@ -40,7 +40,6 @@
 #include <cassert>
 #include <optional>
 
-#include "imex/Dialect/XeTile/Transforms/Blocking.h"
 #include "imex/Dialect/XeTile/Transforms/Passes.h"
 #include "imex/Utils/DebugUtils.h"
 #include "imex/Utils/XeArch.h"
diff --git a/lib/Transforms/CMakeLists.txt b/lib/Transforms/CMakeLists.txt
index e5d635950..d6c1fb7f7 100644
--- a/lib/Transforms/CMakeLists.txt
+++ b/lib/Transforms/CMakeLists.txt
@@ -5,7 +5,6 @@ add_mlir_library(IMEXTransforms
   EmulateNonNativeBF16.cpp
   InsertGPUAllocs.cpp
   LowerMemRefCopy.cpp
-  PropagatePackedLayout.cpp
   RemoveSingleElemVector.cpp
   RemoveTemporaries.cpp
   SerializeSPIRV.cpp
diff --git a/lib/Transforms/PropagatePackedLayout.cpp b/lib/Transforms/PropagatePackedLayout.cpp
deleted file mode 100644
index 2f220be88..000000000
--- a/lib/Transforms/PropagatePackedLayout.cpp
+++ /dev/null
@@ -1,572 +0,0 @@
-//===- PropagatePackedLayout.cpp - PropagatePackedLayout Pass ---*- C++- *-===//
-//
-// Copyright 2024 Intel Corporation
-// Part of the IMEX Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file contains PropagatePackedLayout pass.
-///
-//===----------------------------------------------------------------------===//
-
-#include "imex/Transforms/Passes.h"
-
-#include <numeric>
-
-#include <mlir/Analysis/DataFlow/ConstantPropagationAnalysis.h>
-#include <mlir/Analysis/DataFlow/DeadCodeAnalysis.h>
-#include <mlir/Analysis/DataFlow/SparseAnalysis.h>
-#include <mlir/Dialect/Vector/IR/VectorOps.h>
-#include <mlir/Dialect/XeGPU/IR/XeGPU.h>
-
-namespace imex {
-#define GEN_PASS_DEF_PROPAGATEPACKEDLAYOUT
-#include "imex/Transforms/Passes.h.inc"
-} // namespace imex
-
-namespace {
-// Struct describing current layout per mlir::Value.
-// Have 3 possible states:
-// * Uninitialized (`layout` is empty) - initial state before any layout
-// propagation.
-// * Valid (`layout` holds some non-null value) - `layout` contains the current
-// layout.
-// * Invalid (`layout` holds some nullptr) - cannot determine layout, usually
-// because of layout conflicts.
-struct Layout {
-  Layout() = default;
-  Layout(mlir::Type l) : layout(l) {}
-  Layout(std::nullopt_t) : layout(nullptr) {}
-
-  bool isInitialized() const { return static_cast<bool>(layout); }
-
-  bool isInvalid() const { return isInitialized() && !*layout; }
-
-  mlir::Type getLayout() const { return layout ? *layout : nullptr; }
-
-  void print(llvm::raw_ostream &os) const {
-    if (!isInitialized()) {
-      os << "uninitialized";
-    } else if (isInvalid()) {
-      os << "invalid";
-    } else {
-      os << *layout;
-    }
-  }
-
-  bool operator==(const Layout &rhs) const { return layout == rhs.layout; }
-  bool operator!=(const Layout &rhs) const { return layout != rhs.layout; }
-
-  static Layout meet(const Layout &lhs, const Layout &rhs) {
-    if (!lhs.isInitialized())
-      return rhs;
-
-    if (!rhs.isInitialized())
-      return lhs;
-
-    if (lhs.isInvalid() || rhs.isInvalid() || lhs != rhs)
-      return std::nullopt;
-
-    return lhs;
-  }
-
-  static Layout join(const Layout &lhs, const Layout &rhs) {
-    return meet(lhs, rhs);
-  }
-
-  Layout clone(mlir::Type elemetType) const {
-    if (!layout)
-      return *this;
-
-    auto shaped = mlir::dyn_cast_if_present<mlir::ShapedType>(*layout);
-    if (!shaped)
-      return *this;
-
-    return Layout(shaped.clone(elemetType));
-  }
-
-private:
-  std::optional<mlir::Type> layout;
-};
-
-struct LayoutLattice : public mlir::dataflow::Lattice<Layout> {
-  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LayoutLattice)
-  using Lattice::Lattice;
-
-  // This should not be needed, probably some bug upstream.
-  mlir::ChangeResult meet(const AbstractSparseLattice &rhs) override {
-    return meet(
-        static_cast<const mlir::dataflow::Lattice<Layout> &>(rhs).getValue());
-  }
-
-  mlir::ChangeResult meet(const Layout &rhs) {
-    auto &val = getValue();
-    Layout newValue = Layout::meet(val, rhs);
-    assert(Layout::meet(newValue, val) == newValue &&
-           "expected `meet` to be monotonic");
-    assert(Layout::meet(newValue, rhs) == newValue &&
-           "expected `meet` to be monotonic");
-
-    // Update the current optimistic value if something changed.
-    if (newValue == val)
-      return mlir::ChangeResult::NoChange;
-
-    val = newValue;
-    return mlir::ChangeResult::Change;
-  }
-};
-
-static mlir::Type getPackedType(mlir::VectorType vec, int64_t factor) {
-  const unsigned axis = 0;
-  auto shape = vec.getShape();
-  assert(axis < shape.size());
-  auto newShape = llvm::to_vector(shape);
-  newShape.emplace_back(factor);
-  newShape[axis] /= factor;
-  return mlir::VectorType::get(newShape, vec.getElementType());
-}
-
-static mlir::Type getDpasLayout(mlir::xegpu::DpasOp dpas, mlir::Value arg) {
-  auto type = mlir::cast<mlir::VectorType>(arg.getType());
-  if (type.getRank() != 2)
-    return nullptr;
-
-  auto elementSize = type.getElementType().getIntOrFloatBitWidth() / 8;
-  if (elementSize >= 4)
-    return nullptr;
-
-  auto factor = 4 / elementSize;
-
-  if (dpas.getRhs() == arg)
-    return getPackedType(type, factor);
-
-  return nullptr;
-}
-
-static mlir::Type getElementType(mlir::Type type) {
-  auto shaped = mlir::dyn_cast<mlir::ShapedType>(type);
-  if (!shaped)
-    return type;
-
-  return shaped.getElementType();
-}
-
-// LayoutAnalysisImpl propagates layout info from SSA uses to defs.
-class LayoutAnalysisImpl
-    : public mlir::dataflow::SparseBackwardDataFlowAnalysis<LayoutLattice> {
-public:
-  using SparseBackwardDataFlowAnalysis::SparseBackwardDataFlowAnalysis;
-
-  mlir::LogicalResult
-  visitOperation(mlir::Operation *op, mlir::ArrayRef<LayoutLattice *> operands,
-                 mlir::ArrayRef<const LayoutLattice *> results) override {
-    if (mlir::OpTrait::hasElementwiseMappableTraits(op)) {
-      Layout layout;
-      for (auto &&[res, resLattice] :
-           llvm::zip_equal(op->getResults(), results)) {
-        layout = layout.clone(getElementType(res.getType()));
-        layout = Layout::meet(layout, resLattice->getValue());
-      }
-      for (auto &&[arg, argLattice] :
-           llvm::zip_equal(op->getOperands(), operands)) {
-        layout = layout.clone(getElementType(arg.getType()));
-        layout = Layout::meet(layout, argLattice->getValue());
-      }
-
-      for (auto &&[arg, argLattice] :
-           llvm::zip_equal(op->getOperands(), operands)) {
-        auto tmpLayout = layout.clone(getElementType(arg.getType()));
-        propagateIfChanged(argLattice, argLattice->meet(tmpLayout));
-      }
-
-      return mlir::success();
-    }
-
-    if (auto dpas = mlir::dyn_cast<mlir::xegpu::DpasOp>(op)) {
-      for (auto &&[operand, val] : llvm::zip(operands, dpas.getOperands())) {
-        if (auto newType = getDpasLayout(dpas, val)) {
-          propagateIfChanged(operand, operand->meet(newType));
-        } else {
-          propagateIfChanged(operand, operand->meet(std::nullopt));
-        }
-      }
-      return mlir::success();
-    }
-
-    // Unknown ops: mark all args as invalid layout (no layout change).
-    for (auto operand : operands)
-      propagateIfChanged(operand, operand->meet(std::nullopt));
-
-    return mlir::success();
-  }
-
-  void visitBranchOperand(mlir::OpOperand &operand) override {}
-
-  void visitCallOperand(mlir::OpOperand &operand) override {}
-
-  void setToExitState(LayoutLattice *lattice) override {
-    (void)lattice->meet(std::nullopt);
-  }
-};
-
-class LayoutAnalysis {
-public:
-  LayoutAnalysis() = default;
-
-  mlir::LogicalResult run(mlir::Operation *op) {
-    mlir::SymbolTableCollection symbolTable;
-
-    // These analyses are needed for the data propagating properly (e.g. see
-    // LivenessAnalysis upstream).
-    solver.load<mlir::dataflow::DeadCodeAnalysis>();
-    solver.load<mlir::dataflow::SparseConstantPropagation>();
-
-    solver.load<LayoutAnalysisImpl>(symbolTable);
-    return solver.initializeAndRun(op);
-  }
-
-  mlir::Type getLayout(mlir::Value val) {
-    auto *state = solver.lookupState<LayoutLattice>(val);
-    if (!state)
-      return nullptr;
-
-    return state->getValue().getLayout();
-  }
-
-private:
-  mlir::DataFlowSolver solver;
-};
-} // namespace
-
-static std::pair<unsigned, int64_t> getVNNIInfo(mlir::ShapedType srcType,
-                                                mlir::ShapedType dstType) {
-  auto srcShape = srcType.getShape();
-  auto dstShape = dstType.getShape();
-  if (srcShape.size() == 3 && dstShape.size() == 2)
-    return getVNNIInfo(dstType, srcType);
-
-  if (srcShape.size() == 2 && dstShape.size() == 3) {
-    auto factor = dstShape[2];
-    if (srcShape[1] == dstShape[1] && srcShape[0] / factor == dstShape[0])
-      return {0, factor};
-
-    if (srcShape[0] == dstShape[0] && srcShape[1] / factor == dstShape[1])
-      return {1, factor};
-  }
-  llvm_unreachable("Unsupported shapes");
-}
-
-static llvm::SmallVector<int64_t>
-getVNNIShuffleIndices(mlir::ShapedType srcType, mlir::ShapedType dstType) {
-  auto numElements = srcType.getNumElements();
-  llvm::SmallVector<int64_t> ret(numElements, 0);
-  auto &&[axis, factor] = getVNNIInfo(srcType, dstType);
-  if (axis == 1) {
-    // with axis == 1 it's noop.
-    std::iota(ret.begin(), ret.end(), 0);
-    return ret;
-  }
-  assert(axis == 0);
-  bool toPacked = (srcType.getRank() < dstType.getRank());
-  auto srcShape = srcType.getShape();
-  auto dstShape = dstType.getShape();
-  if (toPacked) {
-    // Convert from contiguous layout to VNNI packed, e.g. from
-    // `vector<16x16xf16>` to `vector<8x16x2xf16>`.
-    assert(srcShape.size() == 2);
-    assert(dstShape.size() == 3);
-    // To arrange the data in VNNI format, the shuffle indices must satisfy
-    // following mapping.
-    // [i, j, k] => i * dstShape[1] * dstShape[2] + j + k * dstShape[1]
-    int shuffleIndex = 0;
-    for (unsigned i = 0; i < dstShape[0]; ++i) {
-      for (unsigned j = 0; j < dstShape[1]; ++j) {
-        for (unsigned k = 0; k < dstShape[2]; ++k) {
-          ret[shuffleIndex++] =
-              i * dstShape[1] * dstShape[2] + j + k * dstShape[1];
-        }
-      }
-    }
-  } else {
-    // Convert from VNNI packed to contiguous layout, e.g. from
-    // `vector<8x16x2xf16>` to `vector<16x16xf16>`.
-    assert(srcShape.size() == 3);
-    assert(dstShape.size() == 2);
-    // To arrange the data in contiguous format, the shuffle indices must
-    // satisfy following mapping, i.e. do the reverse mapping of the above
-    // i * srcShape[1] * srcShape[2] + j + k * srcShape[1] => [i, j, k]
-    int shuffleIndex = 0;
-    for (unsigned i = 0; i < srcShape[0]; ++i) {
-      for (unsigned j = 0; j < srcShape[1]; ++j) {
-        for (unsigned k = 0; k < srcShape[2]; ++k) {
-          ret[i * srcShape[1] * srcShape[2] + j + k * srcShape[1]] =
-              shuffleIndex++;
-        }
-      }
-    }
-  }
-
-  return ret;
-}
-
-static std::pair<mlir::Value, mlir::Operation *>
-makeCast(mlir::OpBuilder &builder, mlir::Value src, mlir::Type srcType,
-         mlir::Type dstType) {
-  if (srcType == dstType)
-    return {src, nullptr};
-
-  auto srcVecType = mlir::cast<mlir::VectorType>(srcType);
-  auto dstVecType = mlir::cast<mlir::VectorType>(dstType);
-  auto numElements = srcVecType.getNumElements();
-  assert(numElements == dstVecType.getNumElements());
-  auto tmpVecType =
-      mlir::VectorType::get(numElements, srcVecType.getElementType());
-
-  auto loc = src.getLoc();
-
-  auto root = builder.create<mlir::vector::ShapeCastOp>(loc, tmpVecType, src);
-  mlir::Value tmp = root;
-
-  tmp = builder.create<mlir::vector::ShuffleOp>(
-      loc, tmp, tmp,
-      builder.getDenseI64ArrayAttr(
-          getVNNIShuffleIndices(srcVecType, dstVecType)));
-
-  return {builder.create<mlir::vector::ShapeCastOp>(loc, dstVecType, tmp),
-          root};
-}
-
-static std::pair<mlir::Value, mlir::Operation *>
-makeCast(mlir::OpBuilder &builder, mlir::Value src, mlir::Type dstType) {
-  return makeCast(builder, src, src.getType(), dstType);
-}
-
-static bool canUpdateElemetwiseInplace(mlir::TypeRange operands,
-                                       mlir::TypeRange results) {
-  mlir::ShapedType shaped;
-  for (auto range : {operands, results}) {
-    for (auto t : range) {
-      auto s = mlir::dyn_cast<mlir::ShapedType>(t);
-      if (!s)
-        return false;
-
-      if (!shaped) {
-        shaped = s;
-        continue;
-      }
-      if (shaped.getShape() != s.getShape())
-        return false;
-    }
-  }
-  return true;
-}
-
-static void updateUnknownOp(mlir::OpBuilder &builder, mlir::Operation &op,
-                            mlir::TypeRange operands, mlir::TypeRange results) {
-  builder.setInsertionPoint(&op);
-  for (auto &&[arg, dstType] : llvm::zip_equal(op.getOpOperands(), operands)) {
-    auto val = arg.get();
-    auto &&[newArg, root] = makeCast(builder, val, dstType, val.getType());
-    if (newArg == val)
-      continue;
-
-    arg.set(newArg);
-  }
-  builder.setInsertionPointAfter(&op);
-  for (auto &&[res, dstType] : llvm::zip_equal(op.getResults(), results)) {
-    auto &&[newRes, root] = makeCast(builder, res, dstType);
-    if (newRes == res)
-      continue;
-
-    res.replaceAllUsesExcept(newRes, root);
-  }
-}
-
-static void updateElemenwiseOp(mlir::OpBuilder &builder, mlir::Operation &op,
-                               mlir::TypeRange operands,
-                               mlir::TypeRange results) {
-  if (canUpdateElemetwiseInplace(operands, results)) {
-    for (auto [res, dstType] : llvm::zip_equal(op.getResults(), results))
-      res.setType(dstType);
-  } else {
-    updateUnknownOp(builder, op, operands, results);
-  }
-}
-
-static void updateLoadOp(mlir::OpBuilder &builder, mlir::xegpu::LoadNdOp op,
-                         mlir::TypeRange operands, mlir::TypeRange results) {
-  assert(results.size() == 1);
-  auto srcType = mlir::cast<mlir::VectorType>(op.getType());
-  auto dstType = mlir::cast<mlir::VectorType>(results.front());
-  if (srcType == dstType)
-    return;
-
-  auto &&[axis, factor] = getVNNIInfo(srcType, dstType);
-  op.getResult().setType(dstType);
-  if (axis == 0)
-    op.setPacked(true);
-}
-
-static void updateDpasOp(mlir::OpBuilder &builder, mlir::xegpu::DpasOp op,
-                         mlir::TypeRange operands, mlir::TypeRange results) {
-  builder.setInsertionPoint(op);
-  for (auto &&[newType, arg] : llvm::zip(operands, op->getOpOperands())) {
-    auto val = arg.get();
-    auto packedType = getDpasLayout(op, val);
-    if (!packedType || packedType == newType)
-      continue;
-
-    auto &&[newArg, root] = makeCast(builder, val, packedType);
-    if (newArg == val)
-      continue;
-
-    arg.set(newArg);
-  }
-
-  builder.setInsertionPointAfter(op);
-  for (auto &&[res, dstType] : llvm::zip_equal(op->getResults(), results)) {
-    auto &&[newRes, root] = makeCast(builder, res, dstType);
-    if (newRes == res)
-      continue;
-
-    res.replaceAllUsesExcept(newRes, root);
-  }
-}
-
-static void updateOpTypes(mlir::OpBuilder &builder, mlir::Operation &op,
-                          mlir::TypeRange operands, mlir::TypeRange results) {
-  // Ignore shape casts as they are generated by the conversion itself.
-  // Ignore RegionBranchOpInterface as it handled in `updateBlockTypes`.
-  if (mlir::isa<mlir::vector::ShapeCastOp, mlir::RegionBranchOpInterface,
-                mlir::RegionBranchTerminatorOpInterface>(op))
-    return;
-
-  if (mlir::OpTrait::hasElementwiseMappableTraits(&op))
-    return updateElemenwiseOp(builder, op, operands, results);
-  if (auto load = mlir::dyn_cast<mlir::xegpu::LoadNdOp>(op))
-    return updateLoadOp(builder, load, operands, results);
-  if (auto dpas = mlir::dyn_cast<mlir::xegpu::DpasOp>(op))
-    return updateDpasOp(builder, dpas, operands, results);
-
-  updateUnknownOp(builder, op, operands, results);
-}
-
-static void handleBranchOpInterface(mlir::OpBuilder &builder,
-                                    mlir::Block &block,
-                                    mlir::RegionBranchOpInterface branch,
-                                    mlir::TypeRange argsTypes) {
-  builder.setInsertionPointToStart(&block);
-
-  mlir::Operation *op = branch.getOperation();
-  llvm::SmallVector<mlir::RegionSuccessor> successors;
-  llvm::SmallVector<mlir::Attribute> operands(op->getNumOperands(), nullptr);
-  branch.getEntrySuccessorRegions(operands, successors);
-
-  for (mlir::RegionSuccessor &successor : successors) {
-    if (block.getParent() != successor.getSuccessor())
-      continue;
-
-    mlir::OperandRange operands = branch.getEntrySuccessorOperands(successor);
-    mlir::ValueRange inputs = successor.getSuccessorInputs();
-    for (auto [arg, input] : llvm::zip(operands, inputs)) {
-      auto idx = mlir::cast<mlir::BlockArgument>(input).getArgNumber();
-      mlir::Type dstType = argsTypes[idx];
-      if (dstType == arg.getType()) {
-        input.setType(dstType);
-        continue;
-      }
-
-      auto &&[newArg, root] = makeCast(builder, arg, dstType);
-      if (newArg == arg)
-        continue;
-
-      arg.replaceAllUsesExcept(newArg, root);
-    }
-  }
-
-  auto terminator = mlir::cast<mlir::RegionBranchTerminatorOpInterface>(
-      block.getTerminator());
-  mlir::SmallVector<mlir::Attribute> operandAttributes(
-      terminator->getNumOperands(), nullptr);
-
-  successors.clear();
-  terminator.getSuccessorRegions(operandAttributes, successors);
-
-  for (const mlir::RegionSuccessor &successor : successors) {
-    if (!successor.isParent())
-      continue;
-
-    mlir::ValueRange inputs = successor.getSuccessorInputs();
-    mlir::OperandRange operands = terminator.getSuccessorOperands(successor);
-    for (auto [operand, input] : llvm::zip(operands, inputs)) {
-      input.setType(operand.getType());
-    }
-  }
-}
-
-static void updateBlockTypes(mlir::OpBuilder &builder, mlir::Block &block,
-                             mlir::TypeRange args) {
-  if (auto iface = mlir::dyn_cast_if_present<mlir::RegionBranchOpInterface>(
-          block.getParentOp()))
-    return handleBranchOpInterface(builder, block, iface, args);
-
-  builder.setInsertionPointToStart(&block);
-  for (auto &&[arg, dstType] : llvm::zip_equal(block.getArguments(), args)) {
-    auto &&[newArg, root] = makeCast(builder, arg, dstType);
-    if (newArg == arg)
-      continue;
-
-    arg.replaceAllUsesExcept(newArg, root);
-  }
-}
-
-namespace imex {
-
-struct PropagatePackedLayoutPass final
-    : public imex::impl::PropagatePackedLayoutBase<PropagatePackedLayoutPass> {
-
-  void runOnOperation() override {
-    mlir::Operation *op = getOperation();
-    LayoutAnalysis analysis;
-    if (mlir::failed(analysis.run(op)))
-      return signalPassFailure();
-
-    auto getLayout = [&](mlir::Value val) -> mlir::Type {
-      auto t = analysis.getLayout(val);
-      if (!t)
-        return val.getType();
-
-      return t;
-    };
-
-    mlir::OpBuilder builder(&getContext());
-    llvm::SmallVector<mlir::Type> operands;
-    op->walk<mlir::WalkOrder::PreOrder>([&](mlir::Block *block) {
-      // Iterate block ops in reverse so op is updated before it's operands.
-      for (mlir::Operation &innerOp : llvm::reverse(block->getOperations())) {
-        operands.clear();
-        for (auto args : {mlir::ValueRange(innerOp.getOperands()),
-                          mlir::ValueRange(innerOp.getResults())}) {
-          for (auto arg : args)
-            operands.emplace_back(getLayout(arg));
-        }
-        mlir::TypeRange range(operands);
-        auto numOperands = innerOp.getNumOperands();
-        updateOpTypes(builder, innerOp, range.take_front(numOperands),
-                      range.drop_front(numOperands));
-      }
-      operands.clear();
-      for (auto arg : block->getArguments())
-        operands.emplace_back(getLayout(arg));
-      updateBlockTypes(builder, *block, operands);
-    });
-  }
-};
-} // namespace imex
-
-std::unique_ptr<mlir::Pass> imex::createPropagatePackedLayoutPass() {
-  return std::make_unique<PropagatePackedLayoutPass>();
-}
diff --git a/lib/Transforms/RemoveSingleElemVector.cpp b/lib/Transforms/RemoveSingleElemVector.cpp
index a1fb84cd5..9e771f0ed 100644
--- a/lib/Transforms/RemoveSingleElemVector.cpp
+++ b/lib/Transforms/RemoveSingleElemVector.cpp
@@ -36,6 +36,36 @@ namespace imex {
 
 namespace {
 
+struct VectorExtractElementOpConversion final
+    : public mlir::OpConversionPattern<mlir::vector::ExtractElementOp> {
+  using mlir::OpConversionPattern<
+      mlir::vector::ExtractElementOp>::OpConversionPattern;
+
+  mlir::LogicalResult
+  matchAndRewrite(mlir::vector::ExtractElementOp extractOp, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto vector = extractOp.getVector();
+    auto vecTy = vector.getType();
+    auto constOp = vector.getDefiningOp<mlir::arith::ConstantOp>();
+
+    if (vecTy.getRank() == 1 && vecTy.getNumElements() == 1 && constOp) {
+      auto value = llvm::dyn_cast<mlir::DenseElementsAttr>(constOp.getValue());
+      if (!value)
+        return mlir::failure();
+
+      auto attr = value.getValues<mlir::TypedAttr>()[0];
+      auto elemTy = vecTy.getElementType();
+
+      auto newVal = rewriter.create<mlir::arith::ConstantOp>(extractOp.getLoc(),
+                                                             elemTy, attr);
+
+      rewriter.replaceOp(extractOp, newVal);
+      return mlir::success();
+    }
+    return mlir::failure();
+  }
+};
+
 struct VectorExtractStridedSliceConversion final
     : public mlir::OpConversionPattern<mlir::vector::ExtractStridedSliceOp> {
   using mlir::OpConversionPattern<
@@ -204,8 +234,13 @@ struct RemoveSingleElemVectorPass final
 
     mlir::ConversionTarget target(*context);
     target.addLegalOp<mlir::arith::ConstantOp>();
-    target.addLegalOp<mlir::vector::ExtractElementOp>();
     target.addLegalOp<mlir::vector::InsertElementOp>();
+    target.addDynamicallyLegalOp<mlir::vector::ExtractElementOp>(
+        [&](mlir::vector::ExtractElementOp op) {
+          auto vecTy = op.getVector().getType();
+          return vecTy.getNumElements() != 1;
+        });
+
     target.markUnknownOpDynamicallyLegal(
         [=](mlir::Operation *op) -> std::optional<bool> {
           if (op->hasTrait<mlir::OpTrait::Vectorizable>()) {
@@ -225,7 +260,8 @@ struct RemoveSingleElemVectorPass final
     mlir::RewritePatternSet patterns(context);
     patterns.add<VectorExtractStridedSliceConversion, VectorizableOpPattern,
                  VectorShffleOpConversion, VectorInterleaveOpConversion,
-                 VectorSplatOpConversion>(typeConverter, context);
+                 VectorSplatOpConversion, VectorExtractElementOpConversion>(
+        typeConverter, context);
     if (mlir::failed(mlir::applyPartialConversion(getOperation(), target,
                                                   std::move(patterns))))
       return signalPassFailure();
diff --git a/test/Conversion/XeTileToXeGPU/array_length_load.mlir b/test/Conversion/XeTileToXeGPU/array_length_load.mlir
index 7fd8f87ca..e3fa432f1 100644
--- a/test/Conversion/XeTileToXeGPU/array_length_load.mlir
+++ b/test/Conversion/XeTileToXeGPU/array_length_load.mlir
@@ -7,12 +7,11 @@ gpu.module @test_kernel {
     %a_loaded = xetile.load_tile %a_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
 
     // Do not let XeGPU do one load with multiple blocks (array_length > 1), where each block is finer than one GRF.
-    //CHECK: xegpu.create_nd_tdesc %arg1[%c0, %c0] : memref<1x32xf16> -> !xegpu.tensor_desc<1x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.create_nd_tdesc %arg1[%c0, %c16] : memref<1x32xf16> -> !xegpu.tensor_desc<1x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: xegpu.create_nd_tdesc %arg1[%c0, %c0] : memref<1x32xf16> -> !xegpu.tensor_desc<1x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
   	%b_tile = xetile.init_tile %b[%c0, %c0] : memref<1x32xf16> -> !xetile.tile<1x32xf16>
     %b_loaded = xetile.load_tile %b_tile : !xetile.tile<1x32xf16> -> vector<1x32xf16>
 
-    %b_loaded_T = vector.transpose %b_loaded, [1, 0] : vector<1x32xf16> to vector<32x1xf16>
+    %b_loaded_T = xetile.transpose %b_loaded, [1, 0] : vector<1x32xf16> -> vector<32x1xf16>
     xegpu.compile_hint
     %b_loaded_T_bc = xetile.broadcast %b_loaded_T [1] : vector<32x1xf16> -> vector<32x32xf16>
 
diff --git a/test/Conversion/XeTileToXeGPU/gemm_preop.mlir b/test/Conversion/XeTileToXeGPU/gemm_preop.mlir
index 4e562faa6..877b7ae11 100755
--- a/test/Conversion/XeTileToXeGPU/gemm_preop.mlir
+++ b/test/Conversion/XeTileToXeGPU/gemm_preop.mlir
@@ -62,8 +62,8 @@ module attributes {gpu.container_module} {
         %27 = xetile.load_tile %arg5 {padding = 0.000000e+00 : f32}  : !xetile.tile<32x32xf16> -> vector<32x32xf16>
         %28 = xetile.load_tile %arg6 {padding = 0.000000e+00 : f32}  : !xetile.tile<32x32xf16> -> vector<32x32xf16>
         xegpu.compile_hint
-        //CHECK-COUNT-32: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-        //CHECK-COUNT-32: {{.*}} = arith.addf {{.*}}, {{.*}} : vector<1x32xf16>
+        //CHECK-COUNT-4: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = [{{.*}}], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+        //CHECK-COUNT-8: {{.*}} = arith.addf {{.*}}, {{.*}} : vector<8x16xf16>
         %29 = arith.addf %27, %27 : vector<32x32xf16>
         xegpu.compile_hint
         %30 = xetile.update_tile_offset %arg5, [%c0,  %c32] : !xetile.tile<32x32xf16>, index, index -> !xetile.tile<32x32xf16>
diff --git a/test/Conversion/XeTileToXeGPU/non_pow2_stacking.mlir b/test/Conversion/XeTileToXeGPU/non_pow2_stacking.mlir
index 82a0c8d7f..b2560df6e 100644
--- a/test/Conversion/XeTileToXeGPU/non_pow2_stacking.mlir
+++ b/test/Conversion/XeTileToXeGPU/non_pow2_stacking.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
 
 module @test_module attributes {gpu.container_module} {
   gpu.module @test_kernel attributes {spirv.target_env = #spirv.target_env<#spirv.vce<v1.4, [Addresses, Float16Buffer, Int64, Int16, Int8, Kernel, Linkage, Vector16, GenericPointer, Groups, Float16, Float64, AtomicFloat32AddEXT, ExpectAssumeKHR, SubgroupDispatch, VectorComputeINTEL, VectorAnyINTEL], [SPV_EXT_shader_atomic_float_add, SPV_KHR_expect_assume, SPV_INTEL_vector_compute]>, api=OpenCL, #spirv.resource_limits<>>} {
@@ -13,14 +13,8 @@ module @test_module attributes {gpu.container_module} {
       %b_valuee = xetile.tile_unpack %b_value {inner_blocks = array<i64: 6, 16>}  : vector<4x2x6x16xf16> -> vector<24x32xf16>
 
       %c_value = arith.addf %a_valuee, %b_valuee : vector<24x32xf16>
-
-      // not a power-of-two (size is 6) inner block stacking reduction
-      // CHECK: %[[STACK1:.*]] = vector.shuffle {{.*}}, {{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-      // CHECK: %[[STACK2:.*]] = vector.shuffle {{.*}}, {{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-      // CHECK: %[[STACK3:.*]] = vector.shuffle {{.*}}, {{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-      // CHECK: %[[STACK4:.*]] = vector.shuffle %[[STACK1]], %[[STACK2]] [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-      // CHECK: %[[STACK5:.*]] = vector.shuffle %[[STACK4]], %[[STACK3]] [0, 1, 2, 3, 4, 5] : vector<4x32xf16>, vector<2x32xf16>
-
+      //CHECK-COUNT-4: {{.*}} = vector.extract_strided_slice %{{.*}} {offsets = {{.*}}, sizes = [6, 32], strides = [1, 1]} : vector<24x32xf16> to vector<6x32xf16>
+      //CHECK-COUNT-8: {{.*}} = vector.extract_strided_slice %{{.*}} {offsets = {{.*}}, sizes = [6, 16], strides = [1, 1]} : vector<6x32xf16> to vector<6x16xf16>
       %c_valuee = xetile.tile_pack %c_value {inner_blocks = array<i64: 6, 16>}  : vector<24x32xf16> -> vector<4x2x6x16xf16>
       xetile.store_tile %c_valuee, %b_tile  : vector<4x2x6x16xf16>, !xetile.tile<24x32xf16, #xetile.tile_attr<inner_blocks = [6, 16]>>
 
diff --git a/test/Conversion/XeTileToXeGPU/reduction.mlir b/test/Conversion/XeTileToXeGPU/reduction.mlir
index fa61a6170..a428b2ade 100644
--- a/test/Conversion/XeTileToXeGPU/reduction.mlir
+++ b/test/Conversion/XeTileToXeGPU/reduction.mlir
@@ -5,235 +5,302 @@ module {
 
     //CHECK: gpu.func @inner_reduction(%[[arg0:.*]]: memref<128x256xf16>, %[[arg1:.*]]: memref<128x256xf16>) {
     gpu.func @inner_reduction(%a: memref<128x256xf16>, %b: memref<128x256xf16>) {
-      //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<16xf16>
       //CHECK: %[[c0:.*]] = arith.constant 0 : index
       %c0 = arith.constant 0 : index
-      %acc = arith.constant dense<0.0> : vector<16xf16>
-      //CHECK: %[[R0:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16>
-      //CHECK-SAME: !xegpu.tensor_desc<16x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK: %[[r0:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xegpu.tensor_desc<16x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %t = xetile.init_tile %a[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-      //CHECK: %[[R1:.*]] = xegpu.load_nd %[[R0]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}>
-      //CHECK-SAME : !xegpu.tensor_desc<16x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<16x32xf16>
+      //CHECK: %[[r1:.*]] = xegpu.load_nd %[[r0]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<16x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<16x32xf16>
+      //CHECK-COUNT-16: {{.*}} = vector.extract_strided_slice %[[r1]] {offsets = {{.*}}, sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
       %v = xetile.load_tile %t : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-
-      //CHECK: %[[R2:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R3:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R4:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R5:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R6:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R7:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R8:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R9:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R10:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R11:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R12:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R13:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R14:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R15:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R16:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R17:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R50:.*]] = math.exp %[[R2]] : vector<1x32xf16>
-      //CHECK: %[[R51:.*]] = math.exp %[[R3]] : vector<1x32xf16>
-      //CHECK: %[[R52:.*]] = math.exp %[[R4]] : vector<1x32xf16>
-      //CHECK: %[[R53:.*]] = math.exp %[[R5]] : vector<1x32xf16>
-      //CHECK: %[[R54:.*]] = math.exp %[[R6]] : vector<1x32xf16>
-      //CHECK: %[[R55:.*]] = math.exp %[[R7]] : vector<1x32xf16>
-      //CHECK: %[[R56:.*]] = math.exp %[[R8]] : vector<1x32xf16>
-      //CHECK: %[[R57:.*]] = math.exp %[[R9]] : vector<1x32xf16>
-      //CHECK: %[[R58:.*]] = math.exp %[[R10]] : vector<1x32xf16>
-      //CHECK: %[[R59:.*]] = math.exp %[[R11]] : vector<1x32xf16>
-      //CHECK: %[[R60:.*]] = math.exp %[[R12]] : vector<1x32xf16>
-      //CHECK: %[[R61:.*]] = math.exp %[[R13]] : vector<1x32xf16>
-      //CHECK: %[[R62:.*]] = math.exp %[[R14]] : vector<1x32xf16>
-      //CHECK: %[[R63:.*]] = math.exp %[[R15]] : vector<1x32xf16>
-      //CHECK: %[[R64:.*]] = math.exp %[[R16]] : vector<1x32xf16>
-      //CHECK: %[[R65:.*]] = math.exp %[[R17]] : vector<1x32xf16>
+      //CHECK-COUNT-16: {{.*}} = math.exp %{{.*}} : vector<1x32xf16>
       %e = math.exp %v: vector<16x32xf16>
-      //CHECK: %[[R83:.*]] = vector.shape_cast %[[R50]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R85:.*]] = vector.shape_cast %[[R51]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R87:.*]] = vector.shape_cast %[[R52]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R89:.*]] = vector.shape_cast %[[R53]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R91:.*]] = vector.shape_cast %[[R54]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R93:.*]] = vector.shape_cast %[[R55]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R95:.*]] = vector.shape_cast %[[R56]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R97:.*]] = vector.shape_cast %[[R57]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R99:.*]] = vector.shape_cast %[[R58]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R101:.*]] = vector.shape_cast %[[R59]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R103:.*]] = vector.shape_cast %[[R60]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R105:.*]] = vector.shape_cast %[[R61]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R107:.*]] = vector.shape_cast %[[R62]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R109:.*]] = vector.shape_cast %[[R63]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R111:.*]] = vector.shape_cast %[[R64]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R113:.*]] = vector.shape_cast %[[R65]] : vector<1x32xf16> to vector<32xf16>
-      //CHECK: %[[R114:.*]] = vector.shuffle %[[R83]], %[[R85]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R115:.*]] = vector.shuffle %[[R83]], %[[R85]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R116:.*]] = arith.addf %[[R114]], %[[R115]] : vector<32xf16>
-      //CHECK: %[[R117:.*]] = vector.shuffle %[[R87]], %[[R89]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R118:.*]] = vector.shuffle %[[R87]], %[[R89]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R119:.*]] = arith.addf %[[R117]], %[[R118]] : vector<32xf16>
-      //CHECK: %[[R120:.*]] = vector.shuffle %[[R91]], %[[R93]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R121:.*]] = vector.shuffle %[[R91]], %[[R93]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R122:.*]] = arith.addf %[[R120]], %[[R121]] : vector<32xf16>
-      //CHECK: %[[R123:.*]] = vector.shuffle %[[R95]], %[[R97]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R124:.*]] = vector.shuffle %[[R95]], %[[R97]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R125:.*]] = arith.addf %[[R123]], %[[R124]] : vector<32xf16>
-      //CHECK: %[[R126:.*]] = vector.shuffle %[[R99]], %[[R101]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R127:.*]] = vector.shuffle %[[R99]], %[[R101]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R128:.*]] = arith.addf %[[R126]], %[[R127]] : vector<32xf16>
-      //CHECK: %[[R129:.*]] = vector.shuffle %[[R103]], %[[R105]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R130:.*]] = vector.shuffle %[[R103]], %[[R105]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R131:.*]] = arith.addf %[[R129]], %[[R130]] : vector<32xf16>
-      //CHECK: %[[R132:.*]] = vector.shuffle %[[R107]], %[[R109]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R133:.*]] = vector.shuffle %[[R107]], %[[R109]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R134:.*]] = arith.addf %[[R132]], %[[R133]] : vector<32xf16>
-      //CHECK: %[[R135:.*]] = vector.shuffle %[[R111]], %[[R113]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R136:.*]] = vector.shuffle %[[R111]], %[[R113]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R137:.*]] = arith.addf %[[R135]], %[[R136]] : vector<32xf16>
-      //CHECK: %[[R138:.*]] = vector.shuffle %[[R116]], %[[R119]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R139:.*]] = vector.shuffle %[[R116]], %[[R119]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R140:.*]] = arith.addf %[[R138]], %[[R139]] : vector<32xf16>
-      //CHECK: %[[R141:.*]] = vector.shuffle %[[R122]], %[[R125]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R142:.*]] = vector.shuffle %[[R122]], %[[R125]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R143:.*]] = arith.addf %[[R141]], %[[R142]] : vector<32xf16>
-      //CHECK: %[[R144:.*]] = vector.shuffle %[[R128]], %[[R131]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R145:.*]] = vector.shuffle %[[R128]], %[[R131]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R146:.*]] = arith.addf %[[R144]], %[[R145]] : vector<32xf16>
-      //CHECK: %[[R147:.*]] = vector.shuffle %[[R134]], %[[R137]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R148:.*]] = vector.shuffle %[[R134]], %[[R137]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R149:.*]] = arith.addf %[[R147]], %[[R148]] : vector<32xf16>
-      //CHECK: %[[R150:.*]] = vector.shuffle %[[R140]], %[[R143]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R151:.*]] = vector.shuffle %[[R140]], %[[R143]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R152:.*]] = arith.addf %[[R150]], %[[R151]] : vector<32xf16>
-      //CHECK: %[[R153:.*]] = vector.shuffle %[[R146]], %[[R149]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R154:.*]] = vector.shuffle %[[R146]], %[[R149]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R155:.*]] = arith.addf %[[R153]], %[[R154]] : vector<32xf16>
-      //CHECK: %[[R156:.*]] = vector.shuffle %[[R152]], %[[R155]] [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R157:.*]] = vector.shuffle %[[R152]], %[[R155]] [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R158:.*]] = arith.addf %[[R156]], %[[R157]] : vector<32xf16>
-      //CHECK: %[[R158A:.*]] = vector.shuffle  %[[R158]],  %[[R158]] [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R158B:.*]] = vector.shuffle  %[[R158]],  %[[R158]] [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31] : vector<32xf16>, vector<32xf16>
-      //CHECK: %[[R158C:.*]] = arith.addf %[[R158A]], %[[R158B]] : vector<16xf16>
-      //CHECK: %[[R159:.*]] = vector.shape_cast %[[R158C]] : vector<16xf16> to vector<16x1xf16>
-      //CHECK: %[[R160:.*]] = vector.shape_cast %[[R159]] : vector<16x1xf16> to vector<16xf16>
-      %r = vector.multi_reduction <add>, %e, %acc [1] : vector<16x32xf16> to vector<16xf16>
-      //CHECK: %[[R161:.*]] = vector.shape_cast %[[R160]] : vector<16xf16> to vector<2x8xf16>
-      %c = vector.shape_cast %r: vector<16xf16> to vector<2x8xf16>
-      //CHECK: %[[R162:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xegpu.tensor_desc<2x8xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK-COUNT-16: {{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31] : vector<32xf16>, vector<32xf16>
+      //CHECK: {{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<16xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<16xf16>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf16>
+      //CHECK-COUNT-8: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+      //CHECK-COUNT-4: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x1xf16>, vector<4x1xf16>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x1xf16>, vector<8x1xf16>
+      %r = xetile.reduction <add>, %e[1] : vector<16x32xf16> -> vector<16x1xf16>
+      //CHECK: %[[r177:.*]] = vector.shape_cast {{.*}} : vector<16x1xf16> to vector<2x8xf16>
+      %c = vector.shape_cast %r: vector<16x1xf16> to vector<2x8xf16>
+      //CHECK: %[[r178:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xegpu.tensor_desc<2x8xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %s = xetile.init_tile %b[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<2x8xf16>
-      //CHECK: xegpu.store_nd %[[R161]], %[[R162]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<2x8xf16>, !xegpu.tensor_desc<2x8xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK: xegpu.store_nd %[[r177]], %[[r178]] <{{.*}}> : vector<2x8xf16>, !xegpu.tensor_desc<2x8xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       xetile.store_tile %c, %s : vector<2x8xf16>, !xetile.tile<2x8xf16>
       gpu.return
     }
 
     gpu.func @inner_reduction_1(%a: memref<8x32xf32>, %b: memref<8x1xf32>) {
       %c0 = arith.constant 0 : index
-      %neg_inf = arith.constant dense<0xFF800000> : vector<8xf32> // -inf
-
+      //CHECK: %[[c0:.*]] = arith.constant 0 : index
+      //CHECK: %[[r0:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c0]]] : memref<8x32xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK: %[[c16:.*]] = arith.constant 16 : index
+      //CHECK: %[[r1:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c16]]] : memref<8x32xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %a_tile = xetile.init_tile %a[%c0, %c0] : memref<8x32xf32> -> !xetile.tile<8x32xf32>
+      //CHECK: %[[r2:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[c0]]] : memref<8x1xf32> -> !xegpu.tensor_desc<8x1xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %b_tile = xetile.init_tile %b[%c0, %c0] : memref<8x1xf32> -> !xetile.tile<8x1xf32>
-
-      //CHECK: xegpu.load_nd %{{.*}} <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<8x16xf32>
-      //CHECK: xegpu.load_nd %{{.*}} <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<8x16xf32>
+      //CHECK: %[[r3:.*]] = xegpu.load_nd %[[r0]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<8x16xf32>
+      //CHECK: %[[r4:.*]] = xegpu.load_nd %[[r1]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<8x16xf32>
+      //CHECK-COUNT-8: {{.*}} = vector.extract_strided_slice %[[r3]] {offsets = {{.*}}, sizes = [1, 16], strides = [1, 1]} : vector<8x16xf32> to vector<1x16xf32>
+      //CHECK-COUNT-8: {{.*}} = vector.extract_strided_slice %[[r4]] {offsets = {{.*}}, sizes = [1, 16], strides = [1, 1]} : vector<8x16xf32> to vector<1x16xf32>
       %a_loaded = xetile.load_tile %a_tile: !xetile.tile<8x32xf32> -> vector<8x32xf32>
 
-      //CHECK: %[[R1:.*]] = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R2:.*]] = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R3:.*]] = arith.maximumf %[[R1]], %[[R2]] : vector<16xf32>
-      //CHECK: %[[R4:.*]] = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R5:.*]] = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R6:.*]] = arith.maximumf %[[R4]], %[[R5]] : vector<16xf32>
-      //CHECK: %[[R7:.*]] = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R8:.*]] = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R9:.*]] = arith.maximumf %[[R7]], %[[R8]] : vector<16xf32>
-      //CHECK: %[[R10:.*]] = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R11:.*]] = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R12:.*]] = arith.maximumf %[[R10]], %[[R11]] : vector<16xf32>
-      //CHECK: %[[R13:.*]] = vector.shuffle %[[R3]], %[[R6]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R14:.*]] = vector.shuffle %[[R3]], %[[R6]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R15:.*]] = arith.maximumf %[[R13]], %[[R14]] : vector<16xf32>
-      //CHECK: %[[R16:.*]] = vector.shuffle %[[R9]], %[[R12]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R17:.*]] = vector.shuffle %[[R9]], %[[R12]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R18:.*]] = arith.maximumf %[[R16]], %[[R17]] : vector<16xf32>
-      //CHECK: %[[R19:.*]] = vector.shuffle %[[R15]], %[[R18]] [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R20:.*]] = vector.shuffle %[[R15]], %[[R18]] [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R21:.*]] = arith.maximumf %[[R19]], %[[R20]] : vector<16xf32>
-      //CHECK: %[[R22:.*]] = vector.shuffle %[[R21]], %[[R21]] [0, 2, 4, 6, 8, 10, 12, 14] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R23:.*]] = vector.shuffle %[[R21]], %[[R21]] [1, 3, 5, 7, 9, 11, 13, 15] : vector<16xf32>, vector<16xf32>
-      //CHECK: %[[R24:.*]] = arith.maximumf %[[R22]], %[[R23]] : vector<8xf32>
-      %3 = vector.multi_reduction <maximumf>, %a_loaded, %neg_inf [1] : vector<8x32xf32> to vector<8xf32> // fastmath<nnan> is implicit here
-      %reduced = vector.shape_cast %3 : vector<8xf32> to vector<8x1xf32>
-      xetile.store_tile %reduced, %b_tile : vector<8x1xf32>, !xetile.tile<8x1xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<1x16xf32>
+      //CHECK: {{.*}} = vector.shape_cast {{.*}} : vector<1x16xf32> to vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<1x16xf32>
+      //CHECK: {{.*}} = vector.shape_cast {{.*}} : vector<1x16xf32> to vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<1x16xf32>
+      //CHECK: {{.*}} = vector.shape_cast {{.*}} : vector<1x16xf32> to vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<1x16xf32>
+      //CHECK: {{.*}} = vector.shape_cast {{.*}} : vector<1x16xf32> to vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<1x16xf32>
+      //CHECK: {{.*}} = vector.shape_cast {{.*}} : vector<1x16xf32> to vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<1x16xf32>
+      //CHECK: {{.*}} = vector.shape_cast {{.*}} : vector<1x16xf32> to vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<1x16xf32>
+      //CHECK: {{.*}} = vector.shape_cast {{.*}} : vector<1x16xf32> to vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 2, 4, 6, 8, 10, 12, 14] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [1, 3, 5, 7, 9, 11, 13, 15] : vector<16xf32>, vector<16xf32>
+      //CHECK: {{.*}} = arith.maximumf %{{.*}}, %{{.*}} : vector<8xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK: {{.*}} = arith.constant {{.*}} : i32
+      //CHECK: {{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<8xf32>
+      //CHECK: {{.*}} = vector.splat %{{.*}} : vector<1x1xf32>
+      //CHECK-COUNT-4: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x1xf32>, vector<1x1xf32>
+      //CHECK-COUNT-2: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x1xf32>, vector<2x1xf32>
+      //CHECK: {{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x1xf32>, vector<4x1xf32>
+      %3 = xetile.reduction <maximumf>, %a_loaded[1] : vector<8x32xf32> -> vector<8x1xf32> // fastmath<nnan> is implicit here
+      //CHECK: xegpu.store_nd {{.*}} : vector<8x1xf32>, !xegpu.tensor_desc<8x1xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      xetile.store_tile %3, %b_tile : vector<8x1xf32>, !xetile.tile<8x1xf32>
       gpu.return
     }
 
     //CHECK: gpu.func @outter_reduction(%[[arg0:.*]]: memref<128x256xf16>, %[[arg1:.*]]: memref<128x256xf16>) {
     gpu.func @outter_reduction(%a: memref<128x256xf16>, %b: memref<128x256xf16>) {
-      //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<32xf16>
       //CHECK: %[[c0:.*]] = arith.constant 0 : index
       %c0 = arith.constant 0 : index
-      %acc = arith.constant dense<0.0> : vector<32xf16>
-      //CHECK: %[[R0:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16>
-      //CHECK-SAME: !xegpu.tensor_desc<16x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK: %[[r0:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xegpu.tensor_desc<16x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %t = xetile.init_tile %a[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-      //CHECK: %[[R1:.*]] = xegpu.load_nd %[[R0]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}>
-      //CHECK-SAME: !xegpu.tensor_desc<16x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<16x32xf16>
+      //CHECK: %[[r1:.*]] = xegpu.load_nd %[[r0]] <{{.*}}> : !xegpu.tensor_desc<16x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<16x32xf16>
+      //CHECK-COUNT-16: {{.*}} = vector.extract_strided_slice %[[r1]] {offsets = {{.*}}, sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
       %v = xetile.load_tile %t : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-      //CHECK: %[[R2:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R3:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R4:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R5:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R6:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R7:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R8:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R9:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R10:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R11:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R12:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R13:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R14:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R15:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R16:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R17:.*]] = vector.extract_strided_slice %[[R1]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R50:.*]] = math.exp %[[R2]] : vector<1x32xf16>
-      //CHECK: %[[R51:.*]] = math.exp %[[R3]] : vector<1x32xf16>
-      //CHECK: %[[R52:.*]] = math.exp %[[R4]] : vector<1x32xf16>
-      //CHECK: %[[R53:.*]] = math.exp %[[R5]] : vector<1x32xf16>
-      //CHECK: %[[R54:.*]] = math.exp %[[R6]] : vector<1x32xf16>
-      //CHECK: %[[R55:.*]] = math.exp %[[R7]] : vector<1x32xf16>
-      //CHECK: %[[R56:.*]] = math.exp %[[R8]] : vector<1x32xf16>
-      //CHECK: %[[R57:.*]] = math.exp %[[R9]] : vector<1x32xf16>
-      //CHECK: %[[R58:.*]] = math.exp %[[R10]] : vector<1x32xf16>
-      //CHECK: %[[R59:.*]] = math.exp %[[R11]] : vector<1x32xf16>
-      //CHECK: %[[R60:.*]] = math.exp %[[R12]] : vector<1x32xf16>
-      //CHECK: %[[R61:.*]] = math.exp %[[R13]] : vector<1x32xf16>
-      //CHECK: %[[R62:.*]] = math.exp %[[R14]] : vector<1x32xf16>
-      //CHECK: %[[R63:.*]] = math.exp %[[R15]] : vector<1x32xf16>
-      //CHECK: %[[R64:.*]] = math.exp %[[R16]] : vector<1x32xf16>
-      //CHECK: %[[R65:.*]] = math.exp %[[R17]] : vector<1x32xf16>
+      //CHECK-COUNT-16: {{.*}} = math.exp {{.*}} : vector<1x32xf16>
       %e = math.exp %v: vector<16x32xf16>
-      //CHECK: %[[R82:.*]] = arith.addf %[[R50]], %[[R51]] : vector<1x32xf16>
-      //CHECK: %[[R83:.*]] = arith.addf %[[R82]], %[[R52]] : vector<1x32xf16>
-      //CHECK: %[[R84:.*]] = arith.addf %[[R83]], %[[R53]] : vector<1x32xf16>
-      //CHECK: %[[R85:.*]] = arith.addf %[[R84]], %[[R54]] : vector<1x32xf16>
-      //CHECK: %[[R86:.*]] = arith.addf %[[R85]], %[[R55]] : vector<1x32xf16>
-      //CHECK: %[[R87:.*]] = arith.addf %[[R86]], %[[R56]] : vector<1x32xf16>
-      //CHECK: %[[R88:.*]] = arith.addf %[[R87]], %[[R57]] : vector<1x32xf16>
-      //CHECK: %[[R89:.*]] = arith.addf %[[R88]], %[[R58]] : vector<1x32xf16>
-      //CHECK: %[[R90:.*]] = arith.addf %[[R89]], %[[R59]] : vector<1x32xf16>
-      //CHECK: %[[R91:.*]] = arith.addf %[[R90]], %[[R60]] : vector<1x32xf16>
-      //CHECK: %[[R92:.*]] = arith.addf %[[R91]], %[[R61]] : vector<1x32xf16>
-      //CHECK: %[[R93:.*]] = arith.addf %[[R92]], %[[R62]] : vector<1x32xf16>
-      //CHECK: %[[R94:.*]] = arith.addf %[[R93]], %[[R63]] : vector<1x32xf16>
-      //CHECK: %[[R95:.*]] = arith.addf %[[R94]], %[[R64]] : vector<1x32xf16>
-      //CHECK: %[[R96:.*]] = arith.addf %[[R95]], %[[R65]] : vector<1x32xf16>
-      //CHECK: %[[R116:.*]] = vector.shape_cast %[[R96]] : vector<1x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R117:.*]] = vector.shape_cast %[[R116]] : vector<1x32xf16> to vector<32xf16>
-      %r = vector.multi_reduction <add>, %e, %acc [0] : vector<16x32xf16> to vector<32xf16>
-      //CHECK: %[[R118:.*]] = vector.shape_cast %[[R117]] : vector<32xf16> to vector<4x8xf16>
-      %c = vector.shape_cast %r: vector<32xf16> to vector<4x8xf16>
-      //CHECK: %[[R119:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xegpu.tensor_desc<4x8xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK: {{.*}} = arith.addf {{.*}}, {{.*}} : vector<1x32xf16>
+      %r = xetile.reduction <add>, %e[0] : vector<16x32xf16> -> vector<1x32xf16>
+      //CHECK: %[[r49:.*]] = vector.shape_cast {{.*}} : vector<1x32xf16> to vector<4x8xf16>
+      %c = vector.shape_cast %r: vector<1x32xf16> to vector<4x8xf16>
+      //CHECK: %[[r50:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xegpu.tensor_desc<4x8xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %s = xetile.init_tile %b[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<4x8xf16>
-      //CHECK: xegpu.store_nd %[[R118]], %[[R119]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<4x8xf16>, !xegpu.tensor_desc<4x8xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK: xegpu.store_nd %[[r49]], %[[r50]] <{{.*}}> : vector<4x8xf16>, !xegpu.tensor_desc<4x8xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       xetile.store_tile %c, %s : vector<4x8xf16>, !xetile.tile<4x8xf16>
       gpu.return
     }
diff --git a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32.mlir b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32.mlir
index 6df1b36bf..605f8d5db 100644
--- a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32.mlir
@@ -4,469 +4,70 @@
 gpu.module @test_kernel {
   // CHECK: gpu.func @test_gemm(%[[A:.*]]: memref<1024x1024xf16>, %[[B:.*]]: memref<1024x1024xf16>, %[[C:.*]]: memref<1024x1024xf32>)
   gpu.func @test_gemm(%A: memref<1024x1024xf16>, %B: memref<1024x1024xf16>, %C: memref<1024x1024xf32>) {
-
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c64:.*]] = arith.constant 64 : index
-    //CHECK: %[[c1024:.*]] = arith.constant 1024 : index
     %c0 = arith.constant 0 : index
     %c64 = arith.constant 64 : index
     %c1024 = arith.constant 1024 : index
-
-    //CHECK: %[[r0:.*]] = gpu.block_id  x
-    //CHECK: %[[r1:.*]] = gpu.block_id  y
     %block_id_x = gpu.block_id x
     %block_id_y = gpu.block_id y
-
-    //CHECK: %[[r0:.*]] = arith.muli %block_id_x, %c64 : index
-    //CHECK: %[[r1:.*]] = arith.muli %block_id_y, %c64 : index
     %m = arith.muli %block_id_x, %c64 : index
     %n = arith.muli %block_id_y, %c64 : index
 
-
-    //CHECK: %[[r2:.*]] = arith.addi %[[r0]], %[[c0]] : index
-    //CHECK: %[[r3:.*]] = arith.addi %[[r1]], %[[c0]] : index
-    //CHECK: %[[r4:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r2]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[r5:.*]] = arith.addi %[[r1]], %[[c16]] : index
-    //CHECK: %[[r6:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r2]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[r7:.*]] = arith.addi %[[r1]], %[[c32]] : index
-    //CHECK: %[[r8:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r2]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c48:.*]] = arith.constant 48 : index
-    //CHECK: %[[r9:.*]] = arith.addi %[[r1]], %[[c48]] : index
-    //CHECK: %[[r10:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r2]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[r11:.*]] = arith.addi %[[r0]], %[[c8]] : index
-    //CHECK: %[[r12:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r11]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r13:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r11]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r14:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r11]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r15:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r11]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r16:.*]] = arith.addi %[[r0]], %[[c16]] : index
-    //CHECK: %[[r17:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r16]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r18:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r16]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r19:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r16]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r20:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r16]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[r21:.*]] = arith.addi %[[r0]], %[[c24]] : index
-    //CHECK: %[[r22:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r21]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r23:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r21]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r24:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r21]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r25:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r21]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r26:.*]] = arith.addi %[[r0]], %[[c32]] : index
-    //CHECK: %[[r27:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r26]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r28:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r26]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r29:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r26]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r30:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r26]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c40:.*]] = arith.constant 40 : index
-    //CHECK: %[[r31:.*]] = arith.addi %[[r0]], %[[c40]] : index
-    //CHECK: %[[r32:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r31]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r33:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r31]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r34:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r31]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r35:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r31]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r36:.*]] = arith.addi %[[r0]], %[[c48]] : index
-    //CHECK: %[[r37:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r36]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r38:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r36]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r39:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r36]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r40:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r36]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c56:.*]] = arith.constant 56 : index
-    //CHECK: %[[r41:.*]] = arith.addi %[[r0]], %[[c56]] : index
-    //CHECK: %[[r42:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r41]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r43:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r41]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r44:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r41]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r45:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r41]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r46:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r2]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r47:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r2]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r48:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r2]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r49:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r2]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r50:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r26]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r51:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r26]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r52:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r26]], %[[r7]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r53:.*]] = xegpu.create_nd_tdesc %[[C]][%[[r26]], %[[r9]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-8: xegpu.create_nd_tdesc %[[C]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     %c_init_tile = xetile.init_tile %C[%m, %n] : memref<1024x1024xf32> -> !xetile.tile<64x64xf32>
-
-    //CHECK: %[[r54:.*]] = xegpu.load_nd %[[r46]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
-    //CHECK: %[[r55:.*]] = xegpu.load_nd %[[r47]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
-    //CHECK: %[[r56:.*]] = xegpu.load_nd %[[r48]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
-    //CHECK: %[[r57:.*]] = xegpu.load_nd %[[r49]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
-    //CHECK: %[[r58:.*]] = xegpu.load_nd %[[r50]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
-    //CHECK: %[[r59:.*]] = xegpu.load_nd %[[r51]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
-    //CHECK: %[[r60:.*]] = xegpu.load_nd %[[r52]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
-    //CHECK: %[[r61:.*]] = xegpu.load_nd %[[r53]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
+    //CHECK-COUNT-8: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
+    //CHECK-COUNT-32: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = {{.*}}, sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
     %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<64x64xf32> -> vector<64x64xf32>
-
-    //CHECK: %[[r62:.*]] = xegpu.create_nd_tdesc %[[A]][%[[r2]], %[[c0]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-    //CHECK: %[[r63:.*]] = xegpu.create_nd_tdesc %[[A]][%[[r2]], %[[c32]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-    //CHECK: %[[r64:.*]] = xegpu.create_nd_tdesc %[[A]][%[[r26]], %[[c0]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-    //CHECK: %[[r65:.*]] = xegpu.create_nd_tdesc %[[A]][%[[r26]], %[[c32]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[A]][{{.*}}] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
     %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<1024x1024xf16> -> !xetile.tile<64x64xf16>
-
-    //CHECK: %[[r66:.*]] = xegpu.create_nd_tdesc %[[B]][%[[c0]], %[[r3]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-    //CHECK: %[[r67:.*]] = xegpu.create_nd_tdesc %[[B]][%[[c0]], %[[r7]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-    //CHECK: %[[r68:.*]] = xegpu.create_nd_tdesc %[[B]][%[[c32]], %[[r3]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-    //CHECK: %[[r69:.*]] = xegpu.create_nd_tdesc %[[B]][%[[c32]], %[[r7]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
+    //CHECK-COUNT-4: xegpu.create_nd_tdesc %[[B]][{{.*}}] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
     %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<1024x1024xf16> -> !xetile.tile<64x64xf16>
-
-    //CHECK: %[[r72:.*]]:16 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c1024]] step %[[c64]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[r62]], %[[arg5:.*]] = %[[r63]], %[[arg6:.*]] = %[[r64]], %[[arg7:.*]] = %[[r65]], %[[arg8:.*]] = %[[r66]],
-    //CHECK-SAME: %[[arg9:.*]] = %[[r67]], %[[arg10:.*]] = %[[r68]], %[[arg11:.*]] = %[[r69]], %[[arg12:.*]] = %[[r54]], %[[arg13:.*]] = %[[r55]],
-    //CHECK-SAME: %[[arg14:.*]] = %[[r56]], %[[arg15:.*]] = %[[r57]], %[[arg16:.*]] = %[[r58]], %[[arg17:.*]] = %[[r59]], %[[arg18:.*]] = %[[r60]],
-    //CHECK-SAME: %[[arg19:.*]] = %[[r61]]) -> (!xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-    //CHECK-SAME: !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-    //CHECK-SAME: !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-    //CHECK-SAME: !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-    //CHECK-SAME: vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>) {
     %out:3 = scf.for %k = %c0 to %c1024 step %c64
       iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
       -> (!xetile.tile<64x64xf16>, !xetile.tile<64x64xf16>, vector<64x64xf32>) {
-      //CHECK: %[[r177:.*]] = vector.extract_strided_slice %[[arg12]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r178:.*]] = vector.extract_strided_slice %[[arg12]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r179:.*]] = vector.extract_strided_slice %[[arg12]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r180:.*]] = vector.extract_strided_slice %[[arg12]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r181:.*]] = vector.extract_strided_slice %[[arg13]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r182:.*]] = vector.extract_strided_slice %[[arg13]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r183:.*]] = vector.extract_strided_slice %[[arg13]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r184:.*]] = vector.extract_strided_slice %[[arg13]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r185:.*]] = vector.extract_strided_slice %[[arg14]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r186:.*]] = vector.extract_strided_slice %[[arg14]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r187:.*]] = vector.extract_strided_slice %[[arg14]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r188:.*]] = vector.extract_strided_slice %[[arg14]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r189:.*]] = vector.extract_strided_slice %[[arg15]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r190:.*]] = vector.extract_strided_slice %[[arg15]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r191:.*]] = vector.extract_strided_slice %[[arg15]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r192:.*]] = vector.extract_strided_slice %[[arg15]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r193:.*]] = vector.extract_strided_slice %[[arg16]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r194:.*]] = vector.extract_strided_slice %[[arg16]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r195:.*]] = vector.extract_strided_slice %[[arg16]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r196:.*]] = vector.extract_strided_slice %[[arg16]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r197:.*]] = vector.extract_strided_slice %[[arg17]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r198:.*]] = vector.extract_strided_slice %[[arg17]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r199:.*]] = vector.extract_strided_slice %[[arg17]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r200:.*]] = vector.extract_strided_slice %[[arg17]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r201:.*]] = vector.extract_strided_slice %[[arg18]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r202:.*]] = vector.extract_strided_slice %[[arg18]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r203:.*]] = vector.extract_strided_slice %[[arg18]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r204:.*]] = vector.extract_strided_slice %[[arg18]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r205:.*]] = vector.extract_strided_slice %[[arg19]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r206:.*]] = vector.extract_strided_slice %[[arg19]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r207:.*]] = vector.extract_strided_slice %[[arg19]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r208:.*]] = vector.extract_strided_slice %[[arg19]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-
 
-      //CHECK: %[[r105:.*]] = xegpu.load_nd %[[arg4]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
-      //CHECK: %[[r106:.*]] = vector.extract %[[r105]][0] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r107:.*]] = vector.extract %[[r105]][1] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r108:.*]] = xegpu.load_nd %[[arg5]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
-      //CHECK: %[[r109:.*]] = vector.extract %[[r108]][0] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r110:.*]] = vector.extract %[[r108]][1] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r111:.*]] = xegpu.load_nd %[[arg6]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
-      //CHECK: %[[r112:.*]] = vector.extract %[[r111]][0] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r113:.*]] = vector.extract %[[r111]][1] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r114:.*]] = xegpu.load_nd %[[arg7]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
-      //CHECK: %[[r115:.*]] = vector.extract %[[r114]][0] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r116:.*]] = vector.extract %[[r114]][1] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r117:.*]] = vector.extract_strided_slice %[[r106]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r118:.*]] = vector.extract_strided_slice %[[r106]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r119:.*]] = vector.extract_strided_slice %[[r106]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r120:.*]] = vector.extract_strided_slice %[[r106]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r121:.*]] = vector.extract_strided_slice %[[r107]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r122:.*]] = vector.extract_strided_slice %[[r107]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r123:.*]] = vector.extract_strided_slice %[[r107]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r124:.*]] = vector.extract_strided_slice %[[r107]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r125:.*]] = vector.extract_strided_slice %[[r109]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r126:.*]] = vector.extract_strided_slice %[[r109]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r127:.*]] = vector.extract_strided_slice %[[r109]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r128:.*]] = vector.extract_strided_slice %[[r109]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r129:.*]] = vector.extract_strided_slice %[[r110]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r130:.*]] = vector.extract_strided_slice %[[r110]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r131:.*]] = vector.extract_strided_slice %[[r110]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r132:.*]] = vector.extract_strided_slice %[[r110]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r133:.*]] = vector.extract_strided_slice %[[r112]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r134:.*]] = vector.extract_strided_slice %[[r112]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r135:.*]] = vector.extract_strided_slice %[[r112]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r136:.*]] = vector.extract_strided_slice %[[r112]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r137:.*]] = vector.extract_strided_slice %[[r113]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r138:.*]] = vector.extract_strided_slice %[[r113]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r139:.*]] = vector.extract_strided_slice %[[r113]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r140:.*]] = vector.extract_strided_slice %[[r113]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r141:.*]] = vector.extract_strided_slice %[[r115]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r142:.*]] = vector.extract_strided_slice %[[r115]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r143:.*]] = vector.extract_strided_slice %[[r115]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r144:.*]] = vector.extract_strided_slice %[[r115]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r145:.*]] = vector.extract_strided_slice %[[r116]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r146:.*]] = vector.extract_strided_slice %[[r116]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r147:.*]] = vector.extract_strided_slice %[[r116]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r148:.*]] = vector.extract_strided_slice %[[r116]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xf16> from vector<2x32x16xf16>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xf16> from vector<2x32x16xf16>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xf16> from vector<2x32x16xf16>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xf16> from vector<2x32x16xf16>
+      //CHECK-COUNT-32: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = {{.*}}, sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
       %a_value = xetile.load_tile %a_tile : !xetile.tile<64x64xf16> -> vector<64x64xf16>
 
-      //CHECK: %[[r149:.*]] = xegpu.load_nd %[[arg8]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
-      //CHECK: %[[r150:.*]] = vector.extract %[[r149]][0] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r151:.*]] = vector.extract %[[r149]][1] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r152:.*]] = xegpu.load_nd %[[arg9]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
-      //CHECK: %[[r153:.*]] = vector.extract %[[r152]][0] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r154:.*]] = vector.extract %[[r152]][1] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r155:.*]] = xegpu.load_nd %[[arg10]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
-      //CHECK: %[[r156:.*]] = vector.extract %[[r155]][0] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r157:.*]] = vector.extract %[[r155]][1] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r158:.*]] = xegpu.load_nd %[[arg11]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
-      //CHECK: %[[r159:.*]] = vector.extract %[[r158]][0] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r160:.*]] = vector.extract %[[r158]][1] : vector<32x16xf16> from vector<2x32x16xf16>
-      //CHECK: %[[r161:.*]] = vector.extract_strided_slice %[[r150]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r162:.*]] = vector.extract_strided_slice %[[r150]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r163:.*]] = vector.extract_strided_slice %[[r151]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r164:.*]] = vector.extract_strided_slice %[[r151]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r165:.*]] = vector.extract_strided_slice %[[r153]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r166:.*]] = vector.extract_strided_slice %[[r153]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r167:.*]] = vector.extract_strided_slice %[[r154]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r168:.*]] = vector.extract_strided_slice %[[r154]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r169:.*]] = vector.extract_strided_slice %[[r156]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r170:.*]] = vector.extract_strided_slice %[[r156]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r171:.*]] = vector.extract_strided_slice %[[r157]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r172:.*]] = vector.extract_strided_slice %[[r157]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r173:.*]] = vector.extract_strided_slice %[[r159]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r174:.*]] = vector.extract_strided_slice %[[r159]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r175:.*]] = vector.extract_strided_slice %[[r160]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r176:.*]] = vector.extract_strided_slice %[[r160]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xf16> from vector<2x32x16xf16>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xf16> from vector<2x32x16xf16>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xf16> from vector<2x32x16xf16>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xf16>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xf16> from vector<2x32x16xf16>
+      //CHECK-COUNT-16: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = {{.*}}, sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
       %b_value = xetile.load_tile %b_tile : !xetile.tile<64x64xf16> -> vector<64x64xf16>
 
-
-      //CHECK: %[[r209:.*]] = xegpu.dpas %[[r117]], %[[r161]], %[[r177]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r210:.*]] = xegpu.dpas %[[r121]], %[[r162]], %[[r209]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r211:.*]] = xegpu.dpas %[[r125]], %[[r169]], %[[r210]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r212:.*]] = xegpu.dpas %[[r129]], %[[r170]], %[[r211]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r213:.*]] = xegpu.dpas %[[r117]], %[[r163]], %[[r181]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r214:.*]] = xegpu.dpas %[[r121]], %[[r164]], %[[r213]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r215:.*]] = xegpu.dpas %[[r125]], %[[r171]], %[[r214]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r216:.*]] = xegpu.dpas %[[r129]], %[[r172]], %[[r215]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r217:.*]] = xegpu.dpas %[[r117]], %[[r165]], %[[r185]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r218:.*]] = xegpu.dpas %[[r121]], %[[r166]], %[[r217]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r219:.*]] = xegpu.dpas %[[r125]], %[[r173]], %[[r218]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r220:.*]] = xegpu.dpas %[[r129]], %[[r174]], %[[r219]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r221:.*]] = xegpu.dpas %[[r117]], %[[r167]], %[[r189]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r222:.*]] = xegpu.dpas %[[r121]], %[[r168]], %[[r221]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r223:.*]] = xegpu.dpas %[[r125]], %[[r175]], %[[r222]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r224:.*]] = xegpu.dpas %[[r129]], %[[r176]], %[[r223]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r225:.*]] = xegpu.dpas %[[r118]], %[[r161]], %[[r178]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r226:.*]] = xegpu.dpas %[[r122]], %[[r162]], %[[r225]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r227:.*]] = xegpu.dpas %[[r126]], %[[r169]], %[[r226]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r228:.*]] = xegpu.dpas %[[r130]], %[[r170]], %[[r227]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r229:.*]] = xegpu.dpas %[[r118]], %[[r163]], %[[r182]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r230:.*]] = xegpu.dpas %[[r122]], %[[r164]], %[[r229]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r231:.*]] = xegpu.dpas %[[r126]], %[[r171]], %[[r230]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r232:.*]] = xegpu.dpas %[[r130]], %[[r172]], %[[r231]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r233:.*]] = xegpu.dpas %[[r118]], %[[r165]], %[[r186]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r234:.*]] = xegpu.dpas %[[r122]], %[[r166]], %[[r233]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r235:.*]] = xegpu.dpas %[[r126]], %[[r173]], %[[r234]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r236:.*]] = xegpu.dpas %[[r130]], %[[r174]], %[[r235]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r237:.*]] = xegpu.dpas %[[r118]], %[[r167]], %[[r190]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r238:.*]] = xegpu.dpas %[[r122]], %[[r168]], %[[r237]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r239:.*]] = xegpu.dpas %[[r126]], %[[r175]], %[[r238]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r240:.*]] = xegpu.dpas %[[r130]], %[[r176]], %[[r239]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r241:.*]] = xegpu.dpas %[[r119]], %[[r161]], %[[r179]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r242:.*]] = xegpu.dpas %[[r123]], %[[r162]], %[[r241]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r243:.*]] = xegpu.dpas %[[r127]], %[[r169]], %[[r242]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r244:.*]] = xegpu.dpas %[[r131]], %[[r170]], %[[r243]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r245:.*]] = xegpu.dpas %[[r119]], %[[r163]], %[[r183]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r246:.*]] = xegpu.dpas %[[r123]], %[[r164]], %[[r245]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r247:.*]] = xegpu.dpas %[[r127]], %[[r171]], %[[r246]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r248:.*]] = xegpu.dpas %[[r131]], %[[r172]], %[[r247]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r249:.*]] = xegpu.dpas %[[r119]], %[[r165]], %[[r187]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r250:.*]] = xegpu.dpas %[[r123]], %[[r166]], %[[r249]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r251:.*]] = xegpu.dpas %[[r127]], %[[r173]], %[[r250]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r252:.*]] = xegpu.dpas %[[r131]], %[[r174]], %[[r251]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r253:.*]] = xegpu.dpas %[[r119]], %[[r167]], %[[r191]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r254:.*]] = xegpu.dpas %[[r123]], %[[r168]], %[[r253]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r255:.*]] = xegpu.dpas %[[r127]], %[[r175]], %[[r254]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r256:.*]] = xegpu.dpas %[[r131]], %[[r176]], %[[r255]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r257:.*]] = xegpu.dpas %[[r120]], %[[r161]], %[[r180]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r258:.*]] = xegpu.dpas %[[r124]], %[[r162]], %[[r257]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r259:.*]] = xegpu.dpas %[[r128]], %[[r169]], %[[r258]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r260:.*]] = xegpu.dpas %[[r132]], %[[r170]], %[[r259]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r261:.*]] = xegpu.dpas %[[r120]], %[[r163]], %[[r184]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r262:.*]] = xegpu.dpas %[[r124]], %[[r164]], %[[r261]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r263:.*]] = xegpu.dpas %[[r128]], %[[r171]], %[[r262]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r264:.*]] = xegpu.dpas %[[r132]], %[[r172]], %[[r263]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r265:.*]] = xegpu.dpas %[[r120]], %[[r165]], %[[r188]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r266:.*]] = xegpu.dpas %[[r124]], %[[r166]], %[[r265]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r267:.*]] = xegpu.dpas %[[r128]], %[[r173]], %[[r266]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r268:.*]] = xegpu.dpas %[[r132]], %[[r174]], %[[r267]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r269:.*]] = xegpu.dpas %[[r120]], %[[r167]], %[[r192]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r270:.*]] = xegpu.dpas %[[r124]], %[[r168]], %[[r269]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r271:.*]] = xegpu.dpas %[[r128]], %[[r175]], %[[r270]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r272:.*]] = xegpu.dpas %[[r132]], %[[r176]], %[[r271]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r273:.*]] = xegpu.dpas %[[r133]], %[[r161]], %[[r193]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r274:.*]] = xegpu.dpas %[[r137]], %[[r162]], %[[r273]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r275:.*]] = xegpu.dpas %[[r141]], %[[r169]], %[[r274]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r276:.*]] = xegpu.dpas %[[r145]], %[[r170]], %[[r275]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r277:.*]] = xegpu.dpas %[[r133]], %[[r163]], %[[r197]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r278:.*]] = xegpu.dpas %[[r137]], %[[r164]], %[[r277]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r279:.*]] = xegpu.dpas %[[r141]], %[[r171]], %[[r278]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r280:.*]] = xegpu.dpas %[[r145]], %[[r172]], %[[r279]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r281:.*]] = xegpu.dpas %[[r133]], %[[r165]], %[[r201]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r282:.*]] = xegpu.dpas %[[r137]], %[[r166]], %[[r281]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r283:.*]] = xegpu.dpas %[[r141]], %[[r173]], %[[r282]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r284:.*]] = xegpu.dpas %[[r145]], %[[r174]], %[[r283]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r285:.*]] = xegpu.dpas %[[r133]], %[[r167]], %[[r205]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r286:.*]] = xegpu.dpas %[[r137]], %[[r168]], %[[r285]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r287:.*]] = xegpu.dpas %[[r141]], %[[r175]], %[[r286]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r288:.*]] = xegpu.dpas %[[r145]], %[[r176]], %[[r287]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r289:.*]] = xegpu.dpas %[[r134]], %[[r161]], %[[r194]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r290:.*]] = xegpu.dpas %[[r138]], %[[r162]], %[[r289]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r291:.*]] = xegpu.dpas %[[r142]], %[[r169]], %[[r290]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r292:.*]] = xegpu.dpas %[[r146]], %[[r170]], %[[r291]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r293:.*]] = xegpu.dpas %[[r134]], %[[r163]], %[[r198]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r294:.*]] = xegpu.dpas %[[r138]], %[[r164]], %[[r293]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r295:.*]] = xegpu.dpas %[[r142]], %[[r171]], %[[r294]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r296:.*]] = xegpu.dpas %[[r146]], %[[r172]], %[[r295]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r297:.*]] = xegpu.dpas %[[r134]], %[[r165]], %[[r202]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r298:.*]] = xegpu.dpas %[[r138]], %[[r166]], %[[r297]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r299:.*]] = xegpu.dpas %[[r142]], %[[r173]], %[[r298]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r300:.*]] = xegpu.dpas %[[r146]], %[[r174]], %[[r299]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r301:.*]] = xegpu.dpas %[[r134]], %[[r167]], %[[r206]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r302:.*]] = xegpu.dpas %[[r138]], %[[r168]], %[[r301]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r303:.*]] = xegpu.dpas %[[r142]], %[[r175]], %[[r302]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r304:.*]] = xegpu.dpas %[[r146]], %[[r176]], %[[r303]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r305:.*]] = xegpu.dpas %[[r135]], %[[r161]], %[[r195]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r306:.*]] = xegpu.dpas %[[r139]], %[[r162]], %[[r305]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r307:.*]] = xegpu.dpas %[[r143]], %[[r169]], %[[r306]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r308:.*]] = xegpu.dpas %[[r147]], %[[r170]], %[[r307]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r309:.*]] = xegpu.dpas %[[r135]], %[[r163]], %[[r199]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r310:.*]] = xegpu.dpas %[[r139]], %[[r164]], %[[r309]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r311:.*]] = xegpu.dpas %[[r143]], %[[r171]], %[[r310]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r312:.*]] = xegpu.dpas %[[r147]], %[[r172]], %[[r311]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r313:.*]] = xegpu.dpas %[[r135]], %[[r165]], %[[r203]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r314:.*]] = xegpu.dpas %[[r139]], %[[r166]], %[[r313]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r315:.*]] = xegpu.dpas %[[r143]], %[[r173]], %[[r314]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r316:.*]] = xegpu.dpas %[[r147]], %[[r174]], %[[r315]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r317:.*]] = xegpu.dpas %[[r135]], %[[r167]], %[[r207]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r318:.*]] = xegpu.dpas %[[r139]], %[[r168]], %[[r317]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r319:.*]] = xegpu.dpas %[[r143]], %[[r175]], %[[r318]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r320:.*]] = xegpu.dpas %[[r147]], %[[r176]], %[[r319]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r321:.*]] = xegpu.dpas %[[r136]], %[[r161]], %[[r196]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r322:.*]] = xegpu.dpas %[[r140]], %[[r162]], %[[r321]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r323:.*]] = xegpu.dpas %[[r144]], %[[r169]], %[[r322]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r324:.*]] = xegpu.dpas %[[r148]], %[[r170]], %[[r323]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r325:.*]] = xegpu.dpas %[[r136]], %[[r163]], %[[r200]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r326:.*]] = xegpu.dpas %[[r140]], %[[r164]], %[[r325]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r327:.*]] = xegpu.dpas %[[r144]], %[[r171]], %[[r326]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r328:.*]] = xegpu.dpas %[[r148]], %[[r172]], %[[r327]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r329:.*]] = xegpu.dpas %[[r136]], %[[r165]], %[[r204]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r330:.*]] = xegpu.dpas %[[r140]], %[[r166]], %[[r329]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r331:.*]] = xegpu.dpas %[[r144]], %[[r173]], %[[r330]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r332:.*]] = xegpu.dpas %[[r148]], %[[r174]], %[[r331]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r333:.*]] = xegpu.dpas %[[r136]], %[[r167]], %[[r208]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r334:.*]] = xegpu.dpas %[[r140]], %[[r168]], %[[r333]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r335:.*]] = xegpu.dpas %[[r144]], %[[r175]], %[[r334]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r336:.*]] = xegpu.dpas %[[r148]], %[[r176]], %[[r335]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-
+      //CHECK-COUNT-128: {{.*}} = xegpu.dpas {{.*}} : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
       %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value : vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf32> -> vector<64x64xf32>
 
-      //CHECK: %[[r337:.*]] = vector.shuffle %[[r212]], %[[r228]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r338:.*]] = vector.shuffle %[[r244]], %[[r260]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r339:.*]] = vector.shuffle %[[r337]], %[[r338]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r340:.*]] = vector.shuffle %[[r276]], %[[r292]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r341:.*]] = vector.shuffle %[[r308]], %[[r324]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r342:.*]] = vector.shuffle %[[r340]], %[[r341]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r343:.*]] = vector.shuffle %[[r216]], %[[r232]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r344:.*]] = vector.shuffle %[[r248]], %[[r264]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r345:.*]] = vector.shuffle %[[r343]], %[[r344]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r346:.*]] = vector.shuffle %[[r280]], %[[r296]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r347:.*]] = vector.shuffle %[[r312]], %[[r328]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r348:.*]] = vector.shuffle %[[r346]], %[[r347]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r349:.*]] = vector.shuffle %[[r220]], %[[r236]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r350:.*]] = vector.shuffle %[[r252]], %[[r268]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r351:.*]] = vector.shuffle %[[r349]], %[[r350]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r352:.*]] = vector.shuffle %[[r284]], %[[r300]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r353:.*]] = vector.shuffle %[[r316]], %[[r332]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r354:.*]] = vector.shuffle %[[r352]], %[[r353]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r355:.*]] = vector.shuffle %[[r224]], %[[r240]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r356:.*]] = vector.shuffle %[[r256]], %[[r272]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r357:.*]] = vector.shuffle %[[r355]], %[[r356]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r358:.*]] = vector.shuffle %[[r288]], %[[r304]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r359:.*]] = vector.shuffle %[[r320]], %[[r336]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r360:.*]] = vector.shuffle %[[r358]], %[[r359]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r361:.*]] = xegpu.update_nd_offset %[[arg4]], [%[[c0]], %[[c64]]] : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-      //CHECK: %[[r362:.*]] = xegpu.update_nd_offset %[[arg5]], [%[[c0]], %[[c64]]] : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-      //CHECK: %[[r363:.*]] = xegpu.update_nd_offset %[[arg6]], [%[[c0]], %[[c64]]] : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-      //CHECK: %[[r364:.*]] = xegpu.update_nd_offset %[[arg7]], [%[[c0]], %[[c64]]] : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-      //CHECK: %[[r365:.*]] = xegpu.update_nd_offset %[[arg8]], [%[[c64]], %[[c0]]] : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-      //CHECK: %[[r366:.*]] = xegpu.update_nd_offset %[[arg9]], [%[[c64]], %[[c0]]] : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-      //CHECK: %[[r367:.*]] = xegpu.update_nd_offset %[[arg10]], [%[[c64]], %[[c0]]] : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-      //CHECK: %[[r368:.*]] = xegpu.update_nd_offset %[[arg11]], [%[[c64]], %[[c0]]] : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
+      //CHECK-COUNT-8: {{.*}} = xegpu.update_nd_offset {{.*}} : !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
       %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c64] : !xetile.tile<64x64xf16>, index, index -> !xetile.tile<64x64xf16>
       %b_next_tile = xetile.update_tile_offset %b_tile, [%c64, %c0] : !xetile.tile<64x64xf16>, index, index -> !xetile.tile<64x64xf16>
-
-      //CHECK: scf.yield %[[r361]], %[[r362]], %[[r363]], %[[r364]], %[[r365]], %[[r366]], %[[r367]], %[[r368]], %[[r339]], %[[r345]], %[[r351]], %[[r357]], %[[r342]], %[[r348]], %[[r354]], %[[r360]]
-      //CHECK-SAME: !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-      //CHECK-SAME: !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-      //CHECK-SAME: !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, !xegpu.tensor_desc<32x16xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>, vector<32x16xf32>, vector<32x16xf32>,
-      //CHECK-SAME: vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>, vector<32x16xf32>
       scf.yield %a_next_tile, %b_next_tile, %c_new_value
         : !xetile.tile<64x64xf16>, !xetile.tile<64x64xf16>, vector<64x64xf32>
     }
-    //CHECK: %[[r73:.*]] = vector.extract_strided_slice %[[r72]]#8 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r74:.*]] = vector.extract_strided_slice %[[r72]]#8 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r75:.*]] = vector.extract_strided_slice %[[r72]]#8 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r76:.*]] = vector.extract_strided_slice %[[r72]]#8 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r77:.*]] = vector.extract_strided_slice %[[r72]]#9 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r78:.*]] = vector.extract_strided_slice %[[r72]]#9 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r79:.*]] = vector.extract_strided_slice %[[r72]]#9 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r80:.*]] = vector.extract_strided_slice %[[r72]]#9 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r81:.*]] = vector.extract_strided_slice %[[r72]]#10 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r82:.*]] = vector.extract_strided_slice %[[r72]]#10 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r83:.*]] = vector.extract_strided_slice %[[r72]]#10 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r84:.*]] = vector.extract_strided_slice %[[r72]]#10 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r85:.*]] = vector.extract_strided_slice %[[r72]]#11 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r86:.*]] = vector.extract_strided_slice %[[r72]]#11 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r87:.*]] = vector.extract_strided_slice %[[r72]]#11 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r88:.*]] = vector.extract_strided_slice %[[r72]]#11 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r89:.*]] = vector.extract_strided_slice %[[r72]]#12 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r90:.*]] = vector.extract_strided_slice %[[r72]]#12 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r91:.*]] = vector.extract_strided_slice %[[r72]]#12 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r92:.*]] = vector.extract_strided_slice %[[r72]]#12 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r93:.*]] = vector.extract_strided_slice %[[r72]]#13 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r94:.*]] = vector.extract_strided_slice %[[r72]]#13 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r95:.*]] = vector.extract_strided_slice %[[r72]]#13 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r96:.*]] = vector.extract_strided_slice %[[r72]]#13 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r97:.*]] = vector.extract_strided_slice %[[r72]]#14 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r98:.*]] = vector.extract_strided_slice %[[r72]]#14 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r99:.*]] = vector.extract_strided_slice %[[r72]]#14 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r100:.*]] = vector.extract_strided_slice %[[r72]]#14 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r101:.*]] = vector.extract_strided_slice %[[r72]]#15 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r102:.*]] = vector.extract_strided_slice %[[r72]]#15 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r103:.*]] = vector.extract_strided_slice %[[r72]]#15 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r104:.*]] = vector.extract_strided_slice %[[r72]]#15 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: xegpu.store_nd %[[r73]], %[[r4]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r77]], %[[r6]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r81]], %[[r8]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r85]], %[[r10]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r74]], %[[r12]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r78]], %[[r13]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r82]], %[[r14]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r86]], %[[r15]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r75]], %[[r17]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r79]], %[[r18]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r83]], %[[r19]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r87]], %[[r20]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r76]], %[[r22]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r80]], %[[r23]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r84]], %[[r24]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r88]], %[[r25]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r89]], %[[r27]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r93]], %[[r28]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r97]], %[[r29]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r101]], %[[r30]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r90]], %[[r32]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r94]], %[[r33]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r98]], %[[r34]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r102]], %[[r35]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r91]], %[[r37]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r95]], %[[r38]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r99]], %[[r39]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r103]], %[[r40]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r92]], %[[r42]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r96]], %[[r43]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r100]], %[[r44]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r104]], %[[r45]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-32: xegpu.store_nd {{.*}} : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     xetile.store_tile %out#2, %c_init_tile: vector<64x64xf32>, !xetile.tile<64x64xf32>
 
     gpu.return
diff --git a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_i8_i32.mlir b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_i8_i32.mlir
index f1cf087eb..7050e3d37 100644
--- a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_i8_i32.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_i8_i32.mlir
@@ -6,77 +6,55 @@ gpu.module @test_kernel {
 
   //CHECK: gpu.func @test_gemm(%[[arg0:.*]]: memref<1024x1024xi8>, %[[arg1:.*]]: memref<1024x1024xi8>, %[[arg2:.*]]: memref<1024x1024xi32>)
   gpu.func @test_gemm(%A: memref<1024x1024xi8>, %B: memref<1024x1024xi8>, %C: memref<1024x1024xi32>) {
-
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
     %c0 = arith.constant 0 : index
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
     %c32 = arith.constant 32 : index
     %c1024 = arith.constant 1024 : index
-    //CHECK: %[[block_id_x:.*]] = gpu.block_id x
     %block_id_x = gpu.block_id x
-    //CHECK: %[[block_id_y:.*]] = gpu.block_id y
     %block_id_y = gpu.block_id y
 
-    //CHECK: %[[r0:.*]] = arith.muli %[[block_id_x]], %[[c32]] : index
-    //CHECK: %[[r1:.*]] = arith.muli %[[block_id_y]], %[[c32]] : index
     %m = arith.muli %block_id_x, %c32 : index
     %n = arith.muli %block_id_y, %c32 : index
 
-    //CHECK: %[[r2:.*]] = arith.addi %[[r0]], %[[c0]] : index
-    //CHECK: %[[r3:.*]] = arith.addi %[[r1]], %[[c0]] : index
-    //CHECK: %[[r4:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r2]], %[[r3]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[r5:.*]] = arith.addi %[[r1]], %[[c16]] : index
-    //CHECK: %[[r6:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r2]], %[[r5]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[r7:.*]] = arith.addi %[[r0]], %[[c8]] : index
-    //CHECK: %[[r8:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r7]], %[[r3]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r9:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r7]], %[[r5]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r10:.*]] = arith.addi %[[r0]], %[[c16]] : index
-    //CHECK: %[[r11:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r10]], %[[r3]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r12:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r10]], %[[r5]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[r13:.*]] = arith.addi %[[r0]], %[[c24]] : index
-    //CHECK: %[[r14:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r13]], %[[r3]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r15:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r13]], %[[r5]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r16:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r2]], %[[r3]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<32x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r17:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r2]], %[[r5]]] : memref<1024x1024xi32> -> !xegpu.tensor_desc<32x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r18:.*]] = xegpu.load_nd %[[r16]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xi32>
-    //CHECK: %[[r19:.*]] = xegpu.load_nd %[[r17]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xi32>
+    //CHECK: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xi32> -> !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xi32> -> !xegpu.tensor_desc<32x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     %c_init_tile = xetile.init_tile %C[%m, %n] : memref<1024x1024xi32> -> !xetile.tile<32x32xi32>
+
+    //CHECK-COUNT-2: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xi32>
+    //CHECK-COUNT-8: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = {{.*}}, sizes = [8, 16], strides = [1, 1]} : vector<32x16xi32> to vector<8x16xi32>
     %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<32x32xi32> -> vector<32x32xi32>
 
-    //CHECK: %20 = xegpu.create_nd_tdesc %[[arg0]][%2, %[[c0]]] : memref<1024x1024xi8> -> !xegpu.tensor_desc<32x32xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: {{.*}} = xegpu.create_nd_tdesc %[[arg0]][{{.*}}] : memref<1024x1024xi8> -> !xegpu.tensor_desc<32x32xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<1024x1024xi8> -> !xetile.tile<32x32xi8>
 
-    //CHECK: %21 = xegpu.create_nd_tdesc %[[arg1]][%c0, %3] : memref<1024x1024xi8> -> !xegpu.tensor_desc<32x16xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
+    //CHECK: {{.*}} = xegpu.create_nd_tdesc %[[arg1]][{{.*}}] : memref<1024x1024xi8> -> !xegpu.tensor_desc<32x16xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
     %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<1024x1024xi8> -> !xetile.tile<32x32xi8>
+
+    //CHECK: {{.*}} = scf.for {{.*}}
     %out:3 = scf.for %k = %c0 to %c1024 step %c32 iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
                   -> (!xetile.tile<32x32xi8>, !xetile.tile<32x32xi8>, vector<32x32xi32>) {
 
-      //CHECK: %[[r39:.*]] = xegpu.load_nd %{{.*}} <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x32xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x32xi8>
-      //CHECK: %[[r40:.*]] = vector.extract_strided_slice %[[r39]] {offsets = [0, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xi8> to vector<8x32xi8>
-      //CHECK: %[[r41:.*]] = vector.extract_strided_slice %[[r39]] {offsets = [8, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xi8> to vector<8x32xi8>
-      //CHECK: %[[r42:.*]] = vector.extract_strided_slice %[[r39]] {offsets = [16, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xi8> to vector<8x32xi8>
-      //CHECK: %[[r43:.*]] = vector.extract_strided_slice %[[r39]] {offsets = [24, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xi8> to vector<8x32xi8>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x32xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x32xi8>
+      //CHECK-COUNT-4: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = {{.*}}, sizes = [8, 32], strides = [1, 1]} : vector<32x32xi8> to vector<8x32xi8>
       %a_value = xetile.load_tile %a_tile : !xetile.tile<32x32xi8> -> vector<32x32xi8>
 
-      //CHECK: %[[r44:.*]] = xegpu.load_nd %{{.*}} <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xi8>
-      //CHECK: %[[r45:.*]] = vector.extract %[[r44]][0] : vector<32x16xi8> from vector<2x32x16xi8>
-      //CHECK: %[[r46:.*]] = vector.extract %[[r44]][1] : vector<32x16xi8> from vector<2x32x16xi8>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x16xi8>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x16xi8> from vector<2x32x16xi8>
       %b_value = xetile.load_tile %b_tile : !xetile.tile<32x32xi8> -> vector<32x32xi8>
 
-      //CHECK-COUNT-8: xegpu.dpas {{.*}} : vector<8x32xi8>, vector<32x16xi8>, vector<8x16xi32> -> vector<8x16xi32>
+      //CHECK-COUNT-8: {{.*}} = xegpu.dpas {{.*}} : vector<8x32xi8>, vector<32x16xi8>, vector<8x16xi32> -> vector<8x16xi32>
       %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value : vector<32x32xi8>, vector<32x32xi8>, vector<32x32xi32> -> vector<32x32xi32>
 
-      //CHECK: xegpu.update_nd_offset %{{.*}}, [%[[c0]], %[[c32]]] : !xegpu.tensor_desc<32x32xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-      //CHECK: xegpu.update_nd_offset %{{.*}}, [%[[c32]], %[[c0]]] : !xegpu.tensor_desc<32x16xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
+      //CHECK: {{.*}} = xegpu.update_nd_offset {{.*}} : !xegpu.tensor_desc<32x32xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c32] : !xetile.tile<32x32xi8>, index, index -> !xetile.tile<32x32xi8>
+      //CHECK: {{.*}} = xegpu.update_nd_offset {{.*}} : !xegpu.tensor_desc<32x16xi8, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
       %b_next_tile = xetile.update_tile_offset %b_tile, [%c32, %c0] : !xetile.tile<32x32xi8>, index, index -> !xetile.tile<32x32xi8>
       scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<32x32xi8>, !xetile.tile<32x32xi8>, vector<32x32xi32>
     }
-
-    //CHECK-COUNT-8: xegpu.store_nd %{{.*}}, %{{.*}} <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xi32>, !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-8: xegpu.store_nd {{.*}} : vector<8x16xi32>, !xegpu.tensor_desc<8x16xi32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     xetile.store_tile %out#2, %c_init_tile {innner_blocks = [8, 16]}: vector<32x32xi32>, !xetile.tile<32x32xi32>
     gpu.return
   }
diff --git a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_tf32_tf32.mlir b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_tf32_tf32.mlir
index 0e29a1fc5..cb961bd7e 100755
--- a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_tf32_tf32.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_tf32_tf32.mlir
@@ -4,185 +4,61 @@ gpu.module @test_kernel {
   //CHECK-LABEL: test_gemm
   //CHECK-SAME: %[[arg0:.*]]: memref<1024x1024xtf32>, %[[arg1:.*]]: memref<1024x1024xtf32>, %[[arg2:.*]]: memref<1024x1024xf32>
   gpu.func @test_gemm(%arg0: memref<1024x1024xtf32>, %arg1: memref<1024x1024xtf32>, %arg2: memref<1024x1024xf32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c64:.*]] = arith.constant 64 : index
-    //CHECK: %[[c1024:.*]] = arith.constant 1024 : index
     %c0 = arith.constant 0 : index
     %c64 = arith.constant 64 : index
     %c1024 = arith.constant 1024 : index
 
-    //CHECK: %[[block_id_x:.*]] = gpu.block_id  x
-    //CHECK: %[[block_id_y:.*]] = gpu.block_id  y
     %block_id_x = gpu.block_id  x
     %block_id_y = gpu.block_id  y
 
-    //CHECK: %[[r0:.*]] = arith.muli %[[block_id_x]], %[[c64]] : index
-    //CHECK: %[[r1:.*]] = arith.muli %[[block_id_y]], %[[c64]] : index
     %0 = arith.muli %block_id_x, %c64 : index
     %1 = arith.muli %block_id_y, %c64 : index
 
-    //CHECK: %[[r2:.*]] = arith.addi %[[r0]], %[[c0]] : index
-    //CHECK: %[[r3:.*]] = arith.addi %[[r1]], %[[c0]] : index
-    //CHECK: %[[r4:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r2]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[r5:.*]] = arith.addi %[[r1]], %[[c16]] : index
-    //CHECK: %[[r6:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r2]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[r7:.*]] = arith.addi %[[r0]], %[[c8]] : index
-    //CHECK: %[[r8:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r7]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r9:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r7]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r10:.*]] = arith.addi %[[r0]], %[[c16]] : index
-    //CHECK: %[[r11:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r10]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r12:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r10]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[r13:.*]] = arith.addi %[[r0]], %[[c24]] : index
-    //CHECK: %[[r14:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r13]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r15:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r13]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r16:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r2]], %[[r3]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r17:.*]] = xegpu.create_nd_tdesc %[[arg2]][%[[r2]], %[[r5]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+
+    //CHECK: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg2]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     %2 = xetile.init_tile %arg2[%0, %1] : memref<1024x1024xf32> -> !xetile.tile<32x32xf32>
 
-    //CHECK: %[[r18:.*]] = xegpu.load_nd %[[r16]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
-    //CHECK: %[[r19:.*]] = xegpu.load_nd %[[r17]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
+    //CHECK-COUNT-2: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xf32>
+    //CHECK-COUNT-8: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = {{.*}}, sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
     %3 = xetile.load_tile %2 {padding = 0.000000e+00 : f32}  : !xetile.tile<32x32xf32> -> vector<32x32xf32>
 
-    //CHECK: %[[r20:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[r2]], %[[c0]]] : memref<1024x1024xtf32> -> !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-    //CHECK: %[[r21:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[r2]], %[[c16]]] : memref<1024x1024xtf32> -> !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg0]][{{.*}}] : memref<1024x1024xtf32> -> !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
     %4 = xetile.init_tile %arg0[%0, %c0] : memref<1024x1024xtf32> -> !xetile.tile<32x32xtf32>
 
-    //CHECK: %[[r22:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[r3]]] : memref<1024x1024xtf32> -> !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[r23:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[r5]]] : memref<1024x1024xtf32> -> !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg1]][{{.*}}] : memref<1024x1024xtf32> -> !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     %5 = xetile.init_tile %arg1[%c0, %1] : memref<1024x1024xtf32> -> !xetile.tile<32x32xtf32>
 
-    //CHECK: %[[r24:.*]]:6 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c1024]] step %[[c64]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[r20]], %[[arg5:.*]] = %[[r21]], %[[arg6:.*]] = %[[r22]], %[[arg7:.*]] = %[[r23]], %[[arg8:.*]] = %[[r18]], %[[arg9:.*]] = %[[r19]])
-    //CHECK-SAME: !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-    //CHECK-SAME: !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-    //CHECK-SAME: !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>,
-    //CHECK-SAME: !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>, vector<32x16xf32>, vector<32x16xf32>
+    //CHECK: {{.*}} = scf.for
     %6:3 = scf.for %arg3 = %c0 to %c1024 step %c64 iter_args(%arg4 = %4, %arg5 = %5, %arg6 = %3) -> (!xetile.tile<32x32xtf32>, !xetile.tile<32x32xtf32>, vector<32x32xf32>) {
-      //CHECK: %[[r65:.*]] = vector.extract_strided_slice %[[arg8]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r66:.*]] = vector.extract_strided_slice %[[arg8]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r67:.*]] = vector.extract_strided_slice %[[arg8]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r68:.*]] = vector.extract_strided_slice %[[arg8]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r69:.*]] = vector.extract_strided_slice %[[arg9]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r70:.*]] = vector.extract_strided_slice %[[arg9]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r71:.*]] = vector.extract_strided_slice %[[arg9]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-      //CHECK: %[[r72:.*]] = vector.extract_strided_slice %[[arg9]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-
-      //CHECK: %[[r33:.*]] = xegpu.load_nd %[[arg4]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x8xtf32>
-      //CHECK: %[[r34:.*]] = vector.extract %[[r33]][0] : vector<32x8xtf32> from vector<2x32x8xtf32>
-      //CHECK: %[[r35:.*]] = vector.extract %[[r33]][1] : vector<32x8xtf32> from vector<2x32x8xtf32>
-      //CHECK: %[[r36:.*]] = xegpu.load_nd %[[arg5]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x8xtf32>
-      //CHECK: %[[r37:.*]] = vector.extract %[[r36]][0] : vector<32x8xtf32> from vector<2x32x8xtf32>
-      //CHECK: %[[r38:.*]] = vector.extract %[[r36]][1] : vector<32x8xtf32> from vector<2x32x8xtf32>
-      //CHECK: %[[r39:.*]] = vector.extract_strided_slice %[[r34]] {offsets = [0, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r40:.*]] = vector.extract_strided_slice %[[r34]] {offsets = [8, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r41:.*]] = vector.extract_strided_slice %[[r34]] {offsets = [16, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r42:.*]] = vector.extract_strided_slice %[[r34]] {offsets = [24, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r43:.*]] = vector.extract_strided_slice %[[r35]] {offsets = [0, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r44:.*]] = vector.extract_strided_slice %[[r35]] {offsets = [8, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r45:.*]] = vector.extract_strided_slice %[[r35]] {offsets = [16, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r46:.*]] = vector.extract_strided_slice %[[r35]] {offsets = [24, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r47:.*]] = vector.extract_strided_slice %[[r37]] {offsets = [0, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r48:.*]] = vector.extract_strided_slice %[[r37]] {offsets = [8, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r49:.*]] = vector.extract_strided_slice %[[r37]] {offsets = [16, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r50:.*]] = vector.extract_strided_slice %[[r37]] {offsets = [24, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r51:.*]] = vector.extract_strided_slice %[[r38]] {offsets = [0, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r52:.*]] = vector.extract_strided_slice %[[r38]] {offsets = [8, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r53:.*]] = vector.extract_strided_slice %[[r38]] {offsets = [16, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
-      //CHECK: %[[r54:.*]] = vector.extract_strided_slice %[[r38]] {offsets = [24, 0], sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x8xtf32>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x8xtf32> from vector<2x32x8xtf32>
+      //CHECK: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>> -> vector<2x32x8xtf32>
+      //CHECK-COUNT-2: {{.*}} = vector.extract {{.*}} : vector<32x8xtf32> from vector<2x32x8xtf32>
+      //CHECK-COUNT-16: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = {{.*}}, sizes = [8, 8], strides = [1, 1]} : vector<32x8xtf32> to vector<8x8xtf32>
       %7 = xetile.load_tile %arg4 {padding = 0.000000e+00 : f32}  : !xetile.tile<32x32xtf32> -> vector<32x32xtf32>
 
-      //CHECK: %[[r55:.*]] = xegpu.load_nd %[[arg6]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xtf32>
-      //CHECK: %[[r56:.*]] = xegpu.load_nd %[[arg7]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xtf32>
-      //CHECK: %[[r57:.*]] = vector.extract_strided_slice %[[r55]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
-      //CHECK: %[[r58:.*]] = vector.extract_strided_slice %[[r55]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
-      //CHECK: %[[r59:.*]] = vector.extract_strided_slice %[[r55]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
-      //CHECK: %[[r60:.*]] = vector.extract_strided_slice %[[r55]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
-      //CHECK: %[[r61:.*]] = vector.extract_strided_slice %[[r56]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
-      //CHECK: %[[r62:.*]] = vector.extract_strided_slice %[[r56]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
-      //CHECK: %[[r63:.*]] = vector.extract_strided_slice %[[r56]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
-      //CHECK: %[[r64:.*]] = vector.extract_strided_slice %[[r56]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
-
+      //CHECK-COUNT-2: {{.*}} = xegpu.load_nd {{.*}} : !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x16xtf32>
+      //CHECK-COUNT-8: {{.*}} = vector.extract_strided_slice {{.*}} {offsets = {{.*}}, sizes = [8, 16], strides = [1, 1]} : vector<32x16xtf32> to vector<8x16xtf32>
       %8 = xetile.load_tile %arg5 {padding = 0.000000e+00 : f32}  : !xetile.tile<32x32xtf32> -> vector<32x32xtf32>
 
-      //CHECK: %[[r73:.*]] = xegpu.dpas %[[r39]], %[[r57]], %[[r65]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r74:.*]] = xegpu.dpas %[[r43]], %[[r58]], %[[r73]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r75:.*]] = xegpu.dpas %[[r47]], %[[r59]], %[[r74]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r76:.*]] = xegpu.dpas %[[r51]], %[[r60]], %[[r75]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r77:.*]] = xegpu.dpas %[[r39]], %[[r61]], %[[r69]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r78:.*]] = xegpu.dpas %[[r43]], %[[r62]], %[[r77]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r79:.*]] = xegpu.dpas %[[r47]], %[[r63]], %[[r78]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r80:.*]] = xegpu.dpas %[[r51]], %[[r64]], %[[r79]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r81:.*]] = xegpu.dpas %[[r40]], %[[r57]], %[[r66]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r82:.*]] = xegpu.dpas %[[r44]], %[[r58]], %[[r81]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r83:.*]] = xegpu.dpas %[[r48]], %[[r59]], %[[r82]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r84:.*]] = xegpu.dpas %[[r52]], %[[r60]], %[[r83]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r85:.*]] = xegpu.dpas %[[r40]], %[[r61]], %[[r70]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r86:.*]] = xegpu.dpas %[[r44]], %[[r62]], %[[r85]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r87:.*]] = xegpu.dpas %[[r48]], %[[r63]], %[[r86]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r88:.*]] = xegpu.dpas %[[r52]], %[[r64]], %[[r87]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r89:.*]] = xegpu.dpas %[[r41]], %[[r57]], %[[r67]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r90:.*]] = xegpu.dpas %[[r45]], %[[r58]], %[[r89]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r91:.*]] = xegpu.dpas %[[r49]], %[[r59]], %[[r90]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r92:.*]] = xegpu.dpas %[[r53]], %[[r60]], %[[r91]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r93:.*]] = xegpu.dpas %[[r41]], %[[r61]], %[[r71]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r94:.*]] = xegpu.dpas %[[r45]], %[[r62]], %[[r93]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r95:.*]] = xegpu.dpas %[[r49]], %[[r63]], %[[r94]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r96:.*]] = xegpu.dpas %[[r53]], %[[r64]], %[[r95]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r97:.*]] = xegpu.dpas %[[r42]], %[[r57]], %[[r68]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r98:.*]] = xegpu.dpas %[[r46]], %[[r58]], %[[r97]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r99:.*]] = xegpu.dpas %[[r50]], %[[r59]], %[[r98]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r100:.*]] = xegpu.dpas %[[r54]], %[[r60]], %[[r99]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r101:.*]] = xegpu.dpas %[[r42]], %[[r61]], %[[r72]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r102:.*]] = xegpu.dpas %[[r46]], %[[r62]], %[[r101]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r103:.*]] = xegpu.dpas %[[r50]], %[[r63]], %[[r102]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r104:.*]] = xegpu.dpas %[[r54]], %[[r64]], %[[r103]] : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r105:.*]] = vector.shuffle %76, %84 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r106:.*]] = vector.shuffle %92, %100 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r107:.*]] = vector.shuffle %105, %106 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-      //CHECK: %[[r108:.*]] = vector.shuffle %80, %88 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r109:.*]] = vector.shuffle %96, %104 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x16xf32>, vector<8x16xf32>
-      //CHECK: %[[r110:.*]] = vector.shuffle %108, %109 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x16xf32>, vector<16x16xf32>
-
-
+      //CHECK-COUNT-32: {{.*}} = xegpu.dpas {{.*}} : vector<8x8xtf32>, vector<8x16xtf32>, vector<8x16xf32> -> vector<8x16xf32>
       %9 = xetile.tile_mma %7, %8, %arg6 : vector<32x32xtf32>, vector<32x32xtf32>, vector<32x32xf32> -> vector<32x32xf32>
 
-      //CHECK: %[[r111:.*]] = xegpu.update_nd_offset %[[arg4]], [%[[c0]], %[[c64]]] : !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
-      //CHECK: %[[r112:.*]] = xegpu.update_nd_offset %[[arg5]], [%[[c0]], %[[c64]]] : !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
+      //CHECK-COUNT-2: {{.*}} = xegpu.update_nd_offset %{{.*}}, [{{.*}}] : !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>
       %10 = xetile.update_tile_offset %arg4, [%c0,  %c64] : !xetile.tile<32x32xtf32>, index, index -> !xetile.tile<32x32xtf32>
 
-      //CHECK: %[[r113:.*]] = xegpu.update_nd_offset %[[arg6]], [%[[c64]], %[[c0]]] : !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-      //CHECK: %[[r114:.*]] = xegpu.update_nd_offset %[[arg7]], [%[[c64]], %[[c0]]] : !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK-COUNT-2: {{.*}} = xegpu.update_nd_offset %{{.*}}, [{{.*}}] : !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %11 = xetile.update_tile_offset %arg5, [%c64,  %c0] : !xetile.tile<32x32xtf32>, index, index -> !xetile.tile<32x32xtf32>
 
-      //CHECK: scf.yield %[[r111]], %[[r112]], %[[r113]], %[[r114]], %[[r107]], %[[r110]]
-      //CHECK-SAME: !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-      //CHECK-SAME: !xegpu.tensor_desc<32x8xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 2 : i64, boundary_check = true>>,
-      //CHECK-SAME: !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>,
-      //CHECK-SAME: !xegpu.tensor_desc<32x16xtf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>, vector<32x16xf32>, vector<32x16xf32>
       scf.yield %10, %11, %9 : !xetile.tile<32x32xtf32>, !xetile.tile<32x32xtf32>, vector<32x32xf32>
     }
-
-    //CHECK: %[[r25:.*]] = vector.extract_strided_slice %[[r24]]#4 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r26:.*]] = vector.extract_strided_slice %[[r24]]#4 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r27:.*]] = vector.extract_strided_slice %[[r24]]#4 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r28:.*]] = vector.extract_strided_slice %[[r24]]#4 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r29:.*]] = vector.extract_strided_slice %[[r24]]#5 {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r30:.*]] = vector.extract_strided_slice %[[r24]]#5 {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r31:.*]] = vector.extract_strided_slice %[[r24]]#5 {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[r32:.*]] = vector.extract_strided_slice %[[r24]]#5 {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: xegpu.store_nd %[[r25]], %[[r4]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r29]], %[[r6]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r26]], %[[r8]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r30]], %[[r9]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r27]], %[[r11]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r31]], %[[r12]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r28]], %[[r14]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r32]], %[[r15]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-8: xegpu.store_nd {{.*}} : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     xetile.store_tile %6#2,  %2 : vector<32x32xf32>, !xetile.tile<32x32xf32>
-    //CHECK: gpu.return
     gpu.return
   }
 }
diff --git a/test/Conversion/XeTileToXeGPU/sg_gemm_transpose_b.mlir b/test/Conversion/XeTileToXeGPU/sg_gemm_transpose_b.mlir
index 0723d481e..451e91b1d 100644
--- a/test/Conversion/XeTileToXeGPU/sg_gemm_transpose_b.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_gemm_transpose_b.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --new-xetile-blocking --canonicalize \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking --canonicalize \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -o -| FileCheck %s
 // CHECK-LABEL: gpu.module @test_kernel {
 gpu.module @test_kernel {
diff --git a/test/Conversion/XeTileToXeGPU/sg_scf_for.mlir b/test/Conversion/XeTileToXeGPU/sg_scf_for.mlir
index b500bf23d..28b27e0ac 100644
--- a/test/Conversion/XeTileToXeGPU/sg_scf_for.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_scf_for.mlir
@@ -3,7 +3,9 @@
 gpu.module @test_kernel {
   //CHECK: gpu.func @sglevel_tiled_gemm(%[[arg0:.*]]: memref<1024x1024xf16>, %[[arg1:.*]]: memref<1024x1024xf16>)
   gpu.func @sglevel_tiled_gemm(%a: memref<1024x1024xf16>, %b: memref<1024x1024xf16>) {
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<32x32xf16>
+    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x32xf16>
+    //CHECK: %[[r0:.*]] = vector.shuffle %[[cst]], %[[cst]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x32xf16>, vector<8x32xf16>
+    //CHECK: %[[r1:.*]] = vector.shuffle %[[r0]], %[[r0]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x32xf16>, vector<16x32xf16>
     //CHECK: %[[c0:.*]] = arith.constant 0 : index
     //CHECK: %[[c64:.*]] = arith.constant 64 : index
     //CHECK: %[[c1024:.*]] = arith.constant 1024 : index
@@ -12,40 +14,40 @@ gpu.module @test_kernel {
     %c64 = arith.constant 64 : index
     %c1024 = arith.constant 1024 : index
 
-    //CHECK: %[[r0:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: %[[r2:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
   	%1 = xetile.init_tile %a[%c0, %c64] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
 
-    //CHECK: %[[r1:.*]]:2 = scf.for %[[arg2:.*]] = %[[c0]] to %[[c1024]] step %[[c64]] iter_args(%[[arg3:.*]] = %[[r0]], %[[arg4:.*]] = %[[cst]]) -> (!xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>, vector<32x32xf16>) {
+    //CHECK: %[[r3:.*]]:2 = scf.for %[[arg2:.*]] = %[[c0]] to %[[c1024]] step %[[c64]] iter_args(%[[arg3:.*]] = %[[r2]], %[[arg4:.*]] = %[[r1]]) -> (!xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>, vector<32x32xf16>) {
     %nexta, %res = scf.for %k= %c0 to %c1024 step %c64 iter_args(%subA = %1, %subB = %cst) -> (!xetile.tile<32x32xf16>, vector<32x32xf16>) {
 
-      //CHECK: %[[r10:.*]] = xegpu.load_nd %[[arg3]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x32xf16>
+      //CHECK: %[[r12:.*]] = xegpu.load_nd %[[arg3]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x32xf16>
       %3 = xetile.load_tile %subA : !xetile.tile<32x32xf16> -> vector<32x32xf16>
 
-      //CHECK: %[[r11:.*]] = xegpu.update_nd_offset %[[arg3]], [%[[c0]], %[[c64]]] : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+      //CHECK: %[[r13:.*]] = xegpu.update_nd_offset %[[arg3]], [%[[c0]], %[[c64]]] : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
       %5 = xetile.update_tile_offset %subA, [%c0, %c64]: !xetile.tile<32x32xf16>, index, index -> !xetile.tile<32x32xf16>
 
-      //CHECK: scf.yield %[[r11]], %[[r10]] : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>, vector<32x32xf16>
+      //CHECK: scf.yield %[[r13]], %[[r12]] : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>, vector<32x32xf16>
       scf.yield %5, %3: !xetile.tile<32x32xf16>, vector<32x32xf16>
     }
-    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[r1]]#1 {offsets = [0, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[r1]]#1 {offsets = [8, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK: %[[r4:.*]] = vector.extract_strided_slice %[[r1]]#1 {offsets = [16, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK: %[[r5:.*]] = vector.extract_strided_slice %[[r1]]#1 {offsets = [24, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK: %[[r4:.*]] = vector.extract_strided_slice %[[r3]]#1 {offsets = [0, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK: %[[r5:.*]] = vector.extract_strided_slice %[[r3]]#1 {offsets = [8, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK: %[[r6:.*]] = vector.extract_strided_slice %[[r3]]#1 {offsets = [16, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK: %[[r7:.*]] = vector.extract_strided_slice %[[r3]]#1 {offsets = [24, 0], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
 
 
-    //CHECK: %[[r6:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: %[[r8:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c0]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[r7:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c8]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: %[[r9:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c8]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[r8:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c16]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: %[[r10:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c16]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[r9:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c24]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: %[[r11:.*]] = xegpu.create_nd_tdesc %[[arg1]][%[[c24]], %[[c64]]] : memref<1024x1024xf16> -> !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
   	%5 = xetile.init_tile %b[%c0, %c64] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
 
-    //CHECK: xegpu.store_nd %[[r2]], %[[r6]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x32xf16>, !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[r3]], %[[r7]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x32xf16>, !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     //CHECK: xegpu.store_nd %[[r4]], %[[r8]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x32xf16>, !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     //CHECK: xegpu.store_nd %[[r5]], %[[r9]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x32xf16>, !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: xegpu.store_nd %[[r6]], %[[r10]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x32xf16>, !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: xegpu.store_nd %[[r7]], %[[r11]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x32xf16>, !xegpu.tensor_desc<8x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
     xetile.store_tile %res, %5: vector<32x32xf16>, !xetile.tile<32x32xf16>
 
     //CHECK: gpu.return
diff --git a/test/Conversion/XeTileToXeGPU/sg_softmax.mlir b/test/Conversion/XeTileToXeGPU/sg_softmax.mlir
index f874de792..60c657297 100644
--- a/test/Conversion/XeTileToXeGPU/sg_softmax.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_softmax.mlir
@@ -13,14 +13,14 @@ gpu.module @test_kernel {
       //CHECK: %[[r3:.*]] = xegpu.load_nd %[[r1]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x32xf16>
       %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
 
-      //CHECK-COUNT-32: {{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-      //CHECK-COUNT-32: {{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-      //CHECK-COUNT-64: {{.*}} = math.exp %{{.*}} : vector<1x32xf16>
+      //CHECK-COUNT-4: {{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+      //CHECK-COUNT-4: {{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+      //CHECK-COUNT-8: {{.*}} = math.exp %{{.*}} : vector<8x32xf16>
       %3 = math.exp %2: vector<32x64xf16>
       //CHECK-COUNT-62: arith.addf {{.*}}, {{.*}} : vector<1x32xf16>
       %4 = xetile.reduction <add>, %3 [0]: vector<32x64xf16> -> vector<1x64xf16>
       %5 = xetile.broadcast %4 [0]: vector<1x64xf16> -> vector<32x64xf16>
-      //CHECK-COUNT-64: arith.divf {{.*}}, {{.*}} : vector<1x32xf16>
+      //CHECK-COUNT-8: arith.divf {{.*}}, {{.*}} : vector<8x32xf16>
       %6 = arith.divf %3, %5: vector<32x64xf16>
       %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
       xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
@@ -37,9 +37,9 @@ gpu.module @test_kernel {
       //CHECK: %[[r2:.*]] = xegpu.load_nd %[[r0]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x32xf16>
       //CHECK: %[[r3:.*]] = xegpu.load_nd %[[r1]] <{l1_hint = #xegpu.cache_hint<cached>, l2_hint = #xegpu.cache_hint<cached>, l3_hint = #xegpu.cache_hint<cached>}> : !xegpu.tensor_desc<32x32xf16, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>> -> vector<32x32xf16>
       %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-      //CHECK-COUNT-32: {{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-      //CHECK-COUNT-32: {{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-      //CHECK-COUNT-64: {{.*}} = math.exp %{{.*}} : vector<1x32xf16>
+      //CHECK-COUNT-4: {{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+      //CHECK-COUNT-4: {{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+      //CHECK-COUNT-8: {{.*}} = math.exp %{{.*}} : vector<8x32xf16>
       %3 = math.exp %2: vector<32x64xf16>
       //CHECK: {{.*}} = arith.addf {{.*}}, {{.*}} : vector<1x32xf16>
       //CHECK: {{.*}} = vector.shape_cast {{.*}} : vector<1x32xf16> to vector<32xf16>
@@ -329,7 +329,7 @@ gpu.module @test_kernel {
       //CHECK: {{.*}} = vector.extract {{.*}}[0, 0] : f16 from vector<1x1xf16>
       //CHECK: {{.*}} = vector.splat {{.*}} : vector<1x32xf16>
       %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
-      // CHECK-COUNT-64: {{.*}} = arith.divf {{.*}}, {{.*}} : vector<1x32xf16>
+      // CHECK-COUNT-8: {{.*}} = arith.divf {{.*}}, {{.*}} : vector<8x32xf16>
       %6 = arith.divf %3, %5: vector<32x64xf16>
       %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
       xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
diff --git a/test/Conversion/XeTileToXeGPU/sg_store_tile.mlir b/test/Conversion/XeTileToXeGPU/sg_store_tile.mlir
index 9b8007a62..901b84f1d 100644
--- a/test/Conversion/XeTileToXeGPU/sg_store_tile.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_store_tile.mlir
@@ -4,36 +4,16 @@
 gpu.module @test_kernel {
   //CHECK: gpu.func @sg_tiled_store(%[[arg0:.*]]: memref<1024x1024xf32>) {
 	gpu.func @sg_tiled_store(%a: memref<1024x1024xf32>) {
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<32x16xf32>
-    //CHECK: %[[R0:.*]] = vector.extract_strided_slice %[[cst]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[R1:.*]] = vector.extract_strided_slice %[[cst]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[R2:.*]] = vector.extract_strided_slice %[[cst]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
-    //CHECK: %[[R3:.*]] = vector.extract_strided_slice %[[cst]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
+
 		%result = arith.constant dense<0.0>: vector<32x32xf32>
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[R4:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c48:.*]] = arith.constant 48 : index
-    //CHECK: %[[R5:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c0]], %[[c48]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[R6:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c8]], %[[c32]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[R7:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c8]], %[[c48]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[R8:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c16]], %[[c32]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[R9:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c16]], %[[c48]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[R10:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c24]], %[[c32]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: %[[R11:.*]] = xegpu.create_nd_tdesc %[[arg0]][%[[c24]], %[[c48]]] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: {{.*}} = xegpu.create_nd_tdesc %[[arg0]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK: {{.*}} = xegpu.create_nd_tdesc %[[arg0]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg0]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg0]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-2: {{.*}} = xegpu.create_nd_tdesc %[[arg0]][{{.*}}] : memref<1024x1024xf32> -> !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
 		%1 = xetile.init_tile %a[0, 32] : memref<1024x1024xf32> -> !xetile.tile<32x32xf32>
 
-    //CHECK: xegpu.store_nd %[[R0]], %[[R4]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[R0]], %[[R5]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[R1]], %[[R6]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[R1]], %[[R7]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[R2]], %[[R8]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[R2]], %[[R9]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[R3]], %[[R10]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
-    //CHECK: xegpu.store_nd %[[R3]], %[[R11]] <{l1_hint = #xegpu.cache_hint<write_back>, l2_hint = #xegpu.cache_hint<write_back>, l3_hint = #xegpu.cache_hint<write_back>}> : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
+    //CHECK-COUNT-8: xegpu.store_nd {{.*}} : vector<8x16xf32>, !xegpu.tensor_desc<8x16xf32, #xegpu.block_tdesc_attr<memory_space =  global, array_length = 1 : i64, boundary_check = true>>
 		xetile.store_tile %result, %1: vector<32x32xf32>, !xetile.tile<32x32xf32>
 		gpu.return
 	}
diff --git a/test/Conversion/XeTileToXeGPU/test_blocking.mlir b/test/Conversion/XeTileToXeGPU/test_blocking.mlir
index 3c09c425f..e24bcf568 100644
--- a/test/Conversion/XeTileToXeGPU/test_blocking.mlir
+++ b/test/Conversion/XeTileToXeGPU/test_blocking.mlir
@@ -4,16 +4,16 @@ gpu.module @test_kernel {
 
 // CHECK-LABEL: test_blocking_elementwise
 //  CHECK-SAME: (%[[A_ORIG:.*]]: vector<64x64xf16>, %[[B_ORIG:.*]]: vector<64x64xf16>)
-//       CHECK: %[[A1:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 1, 32>} : vector<64x64xf16> -> vector<64x2x1x32xf16>
-//       CHECK: %[[B1:.*]] = xetile.tile_pack %[[B_ORIG]] {inner_blocks = array<i64: 1, 32>} : vector<64x64xf16> -> vector<64x2x1x32xf16>
-//       CHECK: %[[RES1:.*]] = arith.addf %[[A1]], %[[B1]] : vector<64x2x1x32xf16>
-//       CHECK: %[[RES_UNP1:.*]] = xetile.tile_unpack %[[RES1]] {inner_blocks = array<i64: 1, 32>} : vector<64x2x1x32xf16> -> vector<64x64xf16>
-//       CHECK: %[[A2:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 1, 32>} : vector<64x64xf16> -> vector<64x2x1x32xf16>
-//       CHECK: %[[RES2:.*]] = arith.negf %[[A2]] : vector<64x2x1x32xf16>
-//       CHECK: %[[RES_UNP2:.*]] = xetile.tile_unpack %[[RES2]] {inner_blocks = array<i64: 1, 32>} : vector<64x2x1x32xf16> -> vector<64x64xf16>
-//       CHECK: %[[A3:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 1, 32>} : vector<64x64xf16> -> vector<64x2x1x32xf16>
-//       CHECK: %[[RES3:.*]] = math.exp %[[A3]] : vector<64x2x1x32xf16>
-//       CHECK: %[[RES_UNP3:.*]] = xetile.tile_unpack %[[RES3]] {inner_blocks = array<i64: 1, 32>} : vector<64x2x1x32xf16> -> vector<64x64xf16>
+//       CHECK: %[[A1:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 64, 32>} : vector<64x64xf16> -> vector<1x2x64x32xf16>
+//       CHECK: %[[B1:.*]] = xetile.tile_pack %[[B_ORIG]] {inner_blocks = array<i64: 64, 32>} : vector<64x64xf16> -> vector<1x2x64x32xf16>
+//       CHECK: %[[RES1:.*]] = arith.addf %[[A1]], %[[B1]] : vector<1x2x64x32xf16>
+//       CHECK: %[[RES_UNP1:.*]] = xetile.tile_unpack %[[RES1]] {inner_blocks = array<i64: 64, 32>} : vector<1x2x64x32xf16> -> vector<64x64xf16>
+//       CHECK: %[[A2:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 64, 32>} : vector<64x64xf16> -> vector<1x2x64x32xf16>
+//       CHECK: %[[RES2:.*]] = arith.negf %[[A2]] : vector<1x2x64x32xf16>
+//       CHECK: %[[RES_UNP2:.*]] = xetile.tile_unpack %[[RES2]] {inner_blocks = array<i64: 64, 32>} : vector<1x2x64x32xf16> -> vector<64x64xf16>
+//       CHECK: %[[A3:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 64, 32>} : vector<64x64xf16> -> vector<1x2x64x32xf16>
+//       CHECK: %[[RES3:.*]] = math.exp %[[A3]] : vector<1x2x64x32xf16>
+//       CHECK: %[[RES_UNP3:.*]] = xetile.tile_unpack %[[RES3]] {inner_blocks = array<i64: 64, 32>} : vector<1x2x64x32xf16> -> vector<64x64xf16>
 //       CHECK: return %[[RES_UNP1]], %[[RES_UNP2]], %[[RES_UNP3]] : vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf16>
 func.func @test_blocking_elementwise(%a: vector<64x64xf16>, %b: vector<64x64xf16>) -> (vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf16>) {
 // Elementwise arith ops are handled in unified way, check some
@@ -31,12 +31,12 @@ gpu.module @test_kernel {
 
 // CHECK-LABEL: test_blocking_transpose
 //  CHECK-SAME: (%[[SRC:.*]]: vector<64x32xf16>)
-//       CHECK: %[[PACK:.*]] = xetile.tile_pack %[[SRC]] {inner_blocks = array<i64: 8, 16>} : vector<64x32xf16> -> vector<8x2x8x16xf16>
-//       CHECK: %[[T:.*]] = vector.transpose %[[PACK]], [1, 0, 3, 2] : vector<8x2x8x16xf16> to vector<2x8x16x8xf16>
-//       CHECK: %[[UNPACK:.*]] = xetile.tile_unpack %[[T]] {inner_blocks = array<i64: 16, 8>} : vector<2x8x16x8xf16> -> vector<32x64xf16>
+//       CHECK: %[[PACK:.*]] = xetile.tile_pack %[[SRC]] {inner_blocks = array<i64: 64, 32>} : vector<64x32xf16> -> vector<1x1x64x32xf16>
+//       CHECK: %[[T:.*]] = xetile.transpose %[[PACK]], [1, 0, 3, 2] : vector<1x1x64x32xf16> -> vector<1x1x32x64xf16>
+//       CHECK: %[[UNPACK:.*]] = xetile.tile_unpack %[[T]] {inner_blocks = array<i64: 32, 64>} : vector<1x1x32x64xf16> -> vector<32x64xf16>
 //       CHECK: return %[[UNPACK]] : vector<32x64xf16>
 func.func @test_blocking_transpose(%a: vector<64x32xf16>) -> vector<32x64xf16> {
-  %0 = vector.transpose %a, [1, 0]: vector<64x32xf16> to vector<32x64xf16>
+  %0 = xetile.transpose %a, [1, 0]: vector<64x32xf16> -> vector<32x64xf16>
   return %0 : vector<32x64xf16>
 }
 
@@ -48,12 +48,12 @@ gpu.module @test_kernel {
 
 // CHECK-LABEL: test_blocking_transpose_small
 //  CHECK-SAME: (%[[SRC:.*]]: vector<16x8xf16>)
-//       CHECK: %[[PACK:.*]] = xetile.tile_pack %[[SRC]] {inner_blocks = array<i64: 8, 8>} : vector<16x8xf16> -> vector<2x1x8x8xf16>
-//       CHECK: %[[T:.*]] = vector.transpose %[[PACK]], [1, 0, 3, 2] : vector<2x1x8x8xf16> to vector<1x2x8x8xf16>
-//       CHECK: %[[UNPACK:.*]] = xetile.tile_unpack %[[T]] {inner_blocks = array<i64: 8, 8>} : vector<1x2x8x8xf16> -> vector<8x16xf16>
+//       CHECK: %[[PACK:.*]] = xetile.tile_pack %[[SRC]] {inner_blocks = array<i64: 16, 8>} : vector<16x8xf16> -> vector<1x1x16x8xf16>
+//       CHECK: %[[T:.*]] = xetile.transpose %[[PACK]], [1, 0, 3, 2] : vector<1x1x16x8xf16> -> vector<1x1x8x16xf16>
+//       CHECK: %[[UNPACK:.*]] = xetile.tile_unpack %[[T]] {inner_blocks = array<i64: 8, 16>} : vector<1x1x8x16xf16> -> vector<8x16xf16>
 //       CHECK: return %[[UNPACK]] : vector<8x16xf16>
 func.func @test_blocking_transpose_small(%a: vector<16x8xf16>) -> vector<8x16xf16> {
-  %0 = vector.transpose %a, [1, 0]: vector<16x8xf16> to vector<8x16xf16>
+  %0 = xetile.transpose %a, [1, 0]: vector<16x8xf16> -> vector<8x16xf16>
   return %0 : vector<8x16xf16>
 }
 
diff --git a/test/Conversion/XeTileToXeGPU/test_order.mlir b/test/Conversion/XeTileToXeGPU/test_order.mlir
index b0eedce8e..6792194ba 100644
--- a/test/Conversion/XeTileToXeGPU/test_order.mlir
+++ b/test/Conversion/XeTileToXeGPU/test_order.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-canonicalization --xetile-blocking --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
+// RUN: imex-opt --split-input-file --xetile-canonicalization --xetile-blocking --cse --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
 
 // CHECK-LABEL: @test_func
 // CHECK-SAME: (%[[ARG0:.*]]: memref<128x64xf16>, %[[ARG1:.*]]: memref<64x128xf16, strided<[1, 64]>>) {
diff --git a/test/Dialect/XeTile/Transforms/Blocking/persistent_kernel.mlir b/test/Dialect/XeTile/Transforms/Blocking/persistent_kernel.mlir
index 9dedca5b3..830194516 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/persistent_kernel.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/persistent_kernel.mlir
@@ -1,4 +1,4 @@
-// RUN:  imex-opt --split-input-file --xetile-init-duplicate --new-xetile-blocking --canonicalize %s -verify-diagnostics -o -| FileCheck %s
+// RUN:  imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking --canonicalize %s -verify-diagnostics -o -| FileCheck %s
 module @gemm attributes {gpu.container_module} {
   gpu.module @test_kernel attributes {spirv.target_env = #spirv.target_env<#spirv.vce<v1.4, [Addresses, Float16Buffer, Int64, Int16, Int8, Kernel, Linkage, Vector16, GenericPointer, Groups, Float16, Float64, AtomicFloat32AddEXT, ExpectAssumeKHR, SubgroupDispatch, VectorComputeINTEL, VectorAnyINTEL], [SPV_EXT_shader_atomic_float_add, SPV_KHR_expect_assume, SPV_INTEL_vector_compute]>, api=OpenCL, #spirv.resource_limits<>>} {
 
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir
index ea442ee8f..85657c085 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --xetile-init-duplicate --new-xetile-blocking --canonicalize --cse %s | FileCheck %s
+// RUN: imex-opt --xetile-init-duplicate --xetile-blocking --canonicalize --cse %s | FileCheck %s
 
 // CHECK-LABEL: gpu.module @test_kernel {
 gpu.module @test_kernel {
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32_slm.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
index 0843b7485..ed5d3ea1a 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --xetile-init-duplicate --new-xetile-blocking --canonicalize --cse %s | FileCheck %s
+// RUN: imex-opt --xetile-init-duplicate --xetile-blocking --canonicalize --cse %s | FileCheck %s
 
 #slm = #xetile.tile_attr<memory_space = 3>
 
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir
index 09de69679..1da86abc2 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --xetile-init-duplicate --new-xetile-blocking --canonicalize --cse %s | FileCheck %s
+// RUN: imex-opt --xetile-init-duplicate --xetile-blocking --canonicalize --cse %s | FileCheck %s
 
 // CHECK-LABEL: gpu.module @test_kernel {
 gpu.module @test_kernel {
diff --git a/test/Dialect/XeTile/Transforms/sg_gemm_4k_4k_4k_f16_f32.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_f16_f32.mlir
similarity index 55%
rename from test/Dialect/XeTile/Transforms/sg_gemm_4k_4k_4k_f16_f32.mlir
rename to test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_f16_f32.mlir
index c1eb0dda4..dd340a76e 100644
--- a/test/Dialect/XeTile/Transforms/sg_gemm_4k_4k_4k_f16_f32.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_f16_f32.mlir
@@ -8,8 +8,8 @@ gpu.module @test_kernel {
     //CHECK: %[[c64:.*]] = arith.constant 64 : index
     //CHECK: %[[c128:.*]] = arith.constant 128 : index
     //CHECK: %[[c4096:.*]] = arith.constant 4096 : index
-    //CHECK: %[[R0:.*]] = gpu.block_id  x
-    //CHECK: %[[R1:.*]] = gpu.block_id  y
+    //CHECK: %[[x:.*]] = gpu.block_id  x
+    //CHECK: %[[y:.*]] = gpu.block_id  y
     %c0 = arith.constant 0 : index
     %c1 = arith.constant 1 : index
     %c64 = arith.constant 64 : index
@@ -18,60 +18,53 @@ gpu.module @test_kernel {
     %block_id_x = gpu.block_id x
     %block_id_y = gpu.block_id y
 
-    //CHECK: %[[R2:.*]] = arith.muli %[[R0]], %[[c64]] : index
-    //CHECK: %[[R3:.*]] = arith.muli %[[R1]], %[[c128]] : index
+    //CHECK: %[[r0:.*]] = arith.muli %[[x]], %[[c64]] : index
+    //CHECK: %[[r1:.*]] = arith.muli %[[y]], %[[c128]] : index
     %m = arith.muli %block_id_x, %c64 : index
     %n = arith.muli %block_id_y, %c128 : index
 
-    //CHECK: %[[R4:.*]] = xetile.init_tile %[[arg2]][%[[R2]], %[[R3]]] : memref<4096x4096xf32>
-    //CHECK-SAME: !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[R5:.*]] = xetile.init_tile %[[arg2]][%[[R2]], %[[R3]]] : memref<4096x4096xf32>
-    //CHECK-SAME: !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK: %[[r2:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<4096x4096xf32> -> !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+    //CHECK: %[[r3:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<4096x4096xf32> -> !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [32, 16]>>
     %c_init_tile = xetile.init_tile %C[%m, %n] : memref<4096x4096xf32> -> !xetile.tile<64x128xf32>
 
-    //CHECK: %[[R6:.*]] = xetile.load_tile %[[R5]]
-    //CHECK-SAME: !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x8x32x16xf32>
+    //CHECK: %[[r4:.*]] = xetile.load_tile %[[r3]] : !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x8x32x16xf32>
+    //CHECK: %[[r5:.*]] = xetile.tile_unpack %[[r4]] {inner_blocks = array<i64: 32, 16>} : vector<2x8x32x16xf32> -> vector<64x128xf32>
     %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<64x128xf32> -> vector<64x128xf32>
 
-    //CHECK: %[[R7:.*]] = xetile.init_tile %[[arg0]][%[[R2]], %[[c0]]] : memref<4096x4096xf16>
-    //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg0]][%[[r0]], %[[c0]]] : memref<4096x4096xf16> -> !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
     %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<4096x4096xf16> -> !xetile.tile<64x128xf16>
 
-    //CHECK: %[[R8:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R3]]] : memref<4096x4096xf16>
-    //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[r1]]] : memref<4096x4096xf16> -> !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
     %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<4096x4096xf16> -> !xetile.tile<128x128xf16>
 
-    //CHECK: %[[R9:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c4096]] step %[[c128]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[R7]], %[[arg5:.*]] = %[[R8]], %[[arg6:.*]] = %[[R6]])
+    //CHECK: %[[r8:.*]] = xetile.tile_pack %[[r5]] {inner_blocks = array<i64: 8, 16>} : vector<64x128xf32> -> vector<8x8x8x16xf32>
+    //CHECK: %[[r9:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c4096]] step %[[c128]]
+    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[r6]], %[[arg5:.*]] = %[[r7]], %[[arg6:.*]] = %[[r8]])
     //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<2x8x32x16xf32>
+    //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<8x8x8x16xf32>
     %out:3 = scf.for %k = %c0 to %c4096 step %c128
       iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
       -> (!xetile.tile<64x128xf16>, !xetile.tile<128x128xf16>, vector<64x128xf32>) {
-      //CHECK: %[[R10:.*]] = xetile.tile_unpack %[[arg6]] {inner_blocks = array<i64: 32, 16>}  : vector<2x8x32x16xf32> -> vector<64x128xf32>
-
-      //CHECK: %[[R12:.*]] = xetile.load_tile %[[arg4]]
+      //CHECK: %[[r10:.*]] = xetile.load_tile %[[arg4]]
       //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x8x32x16xf16>
-      //CHECK: %[[R13:.*]] = xetile.tile_unpack %[[R12]] {inner_blocks = array<i64: 32, 16>}  : vector<2x8x32x16xf16> -> vector<64x128xf16>
+      //CHECK: %[[r11:.*]] = xetile.tile_unpack %[[r10]] {inner_blocks = array<i64: 32, 16>}  : vector<2x8x32x16xf16> -> vector<64x128xf16>
       %a_value = xetile.load_tile %a_tile : !xetile.tile<64x128xf16> -> vector<64x128xf16>
 
-      //CHECK: %[[R14:.*]] = xetile.load_tile %[[arg5]]
+      //CHECK: %[[r12:.*]] = xetile.load_tile %[[arg5]]
       //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<4x8x32x16xf16>
-      //CHECK: %[[R15:.*]] = xetile.tile_unpack %[[R14]] {inner_blocks = array<i64: 32, 16>}  : vector<4x8x32x16xf16> -> vector<128x128xf16>
+      //CHECK: %[[r13:.*]] = xetile.tile_unpack %[[r12]] {inner_blocks = array<i64: 32, 16>}  : vector<4x8x32x16xf16> -> vector<128x128xf16>
       %b_value = xetile.load_tile %b_tile : !xetile.tile<128x128xf16> -> vector<128x128xf16>
 
-      //CHECK: %[[R16:.*]] = xetile.tile_pack %[[R13]] {inner_blocks = array<i64: 8, 16>}  : vector<64x128xf16> -> vector<8x8x8x16xf16>
-      //CHECK: %[[R17:.*]] = xetile.tile_pack %[[R15]] {inner_blocks = array<i64: 16, 16>}  : vector<128x128xf16> -> vector<8x8x16x16xf16>
-      //CHECK: %[[R19:.*]] = xetile.tile_pack %[[R10]] {inner_blocks = array<i64: 8, 16>}  : vector<64x128xf32> -> vector<8x8x8x16xf32>
-      //CHECK: %[[R20:.*]] = xetile.tile_mma %[[R16]], %[[R17]], %[[R19]] : vector<8x8x8x16xf16>, vector<8x8x16x16xf16>, vector<8x8x8x16xf32> -> vector<8x8x8x16xf32>
-      //CHECK: %[[R21:.*]] = xetile.tile_unpack %[[R20]] {inner_blocks = array<i64: 8, 16>}  : vector<8x8x8x16xf32> -> vector<64x128xf32>
+      //CHECK: %[[r14:.*]] = xetile.tile_pack %[[r11]] {inner_blocks = array<i64: 8, 16>}  : vector<64x128xf16> -> vector<8x8x8x16xf16>
+      //CHECK: %[[r15:.*]] = xetile.tile_pack %[[r13]] {inner_blocks = array<i64: 16, 16>}  : vector<128x128xf16> -> vector<8x8x16x16xf16>
+      //CHECK: %[[r16:.*]] = xetile.tile_mma %[[r14]], %[[r15]], %[[arg6]] : vector<8x8x8x16xf16>, vector<8x8x16x16xf16>, vector<8x8x8x16xf32> -> vector<8x8x8x16xf32>
       %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value
         : vector<64x128xf16>, vector<128x128xf16>, vector<64x128xf32> -> vector<64x128xf32>
 
-      //CHECK: %[[R22:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c128]]]
+      //CHECK: %[[r17:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c128]]]
       //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index
       //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK: %[[R23:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c128]],  %[[c0]]]
+      //CHECK: %[[r18:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c128]],  %[[c0]]]
       //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index
       //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
       %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c128]
@@ -79,17 +72,13 @@ gpu.module @test_kernel {
       %b_next_tile = xetile.update_tile_offset %b_tile, [%c128, %c0]
         : !xetile.tile<128x128xf16>, index, index -> !xetile.tile<128x128xf16>
 
-      //CHECK: %[[R24:.*]] = xetile.tile_pack %[[R21]] {inner_blocks = array<i64: 32, 16>}  : vector<64x128xf32> -> vector<2x8x32x16xf32>
-      //CHECK: scf.yield %[[R22]], %[[R23]], %[[R24]]
+      //CHECK: scf.yield %[[r17]], %[[r18]], %[[r16]]
       //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<2x8x32x16xf32>
+      //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<8x8x8x16xf32>
       scf.yield %a_next_tile, %b_next_tile, %c_new_value
         : !xetile.tile<64x128xf16>, !xetile.tile<128x128xf16>, vector<64x128xf32>
     }
-    //CHECK: %[[R10:.*]] = xetile.tile_unpack %[[R9]]#2 {inner_blocks = array<i64: 32, 16>}  : vector<2x8x32x16xf32> -> vector<64x128xf32>
-
-    //CHECK: %[[R11:.*]] = xetile.tile_pack %[[R10]] {inner_blocks = array<i64: 8, 16>}  : vector<64x128xf32> -> vector<8x8x8x16xf32>
-    //CHECK: xetile.store_tile %[[R11]],  %[[R4]] : vector<8x8x8x16xf32>, !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+    //CHECK: xetile.store_tile %[[r9]]#2,  %[[r2]] : vector<8x8x8x16xf32>, !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
     xetile.store_tile %out#2, %c_init_tile : vector<64x128xf32>, !xetile.tile<64x128xf32>
 
     //CHECK: gpu.return
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_i8_i32.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_i8_i32.mlir
new file mode 100644
index 000000000..4a026247f
--- /dev/null
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_i8_i32.mlir
@@ -0,0 +1,78 @@
+// RUN: imex-opt -xetile-init-duplicate --xetile-blocking --canonicalize --cse %s | FileCheck %s
+
+gpu.module @test_kernel {
+
+  //CHECK: gpu.func @test_gemm(%[[arg0:.*]]: memref<4096x4096xi8>, %[[arg1:.*]]: memref<4096x4096xi8>, %[[arg2:.*]]: memref<4096x4096xi32>) {
+  gpu.func @test_gemm(%A: memref<4096x4096xi8>, %B: memref<4096x4096xi8>, %C: memref<4096x4096xi32>) {
+
+    //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[c128:.*]] = arith.constant 128 : index
+    //CHECK: %[[c256:.*]] = arith.constant 256 : index
+    //CHECK: %[[c4096:.*]] = arith.constant 4096 : index
+
+
+    //CHECK: %[[x:.*]] = gpu.block_id  x
+    //CHECK: %[[y:.*]] = gpu.block_id  y
+    //CHECK: %[[r0:.*]] = arith.muli %[[x]], %[[c128]] : index
+    //CHECK: %[[r1:.*]] = arith.muli %[[y]], %[[c256]] : index
+    //CHECK: %[[r2:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+    //CHECK: %[[r3:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK: %[[r4:.*]] = xetile.load_tile %[[r3]] : !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<4x16x32x16xi32>
+    //CHECK: %[[r5:.*]] = xetile.tile_unpack %[[r4]] {inner_blocks = array<i64: 32, 16>} : vector<4x16x32x16xi32> -> vector<128x256xi32>
+    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg0]][%[[r0]], %[[c0]]] : memref<4096x4096xi8> -> !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
+    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[r1]]] : memref<4096x4096xi8> -> !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK: %[[r8:.*]] = xetile.tile_pack %[[r5]] {inner_blocks = array<i64: 8, 16>} : vector<128x256xi32> -> vector<16x16x8x16xi32>
+
+
+
+    %c0 = arith.constant 0 : index
+    %c1 = arith.constant 1 : index
+    %c128 = arith.constant 128 : index
+    %c256 = arith.constant 256 : index
+    %c4096 = arith.constant 4096 : index
+    %block_id_x = gpu.block_id x
+    %block_id_y = gpu.block_id y
+    %m = arith.muli %block_id_x, %c128 : index
+    %n = arith.muli %block_id_y, %c256 : index
+
+    %c_init_tile = xetile.init_tile %C[%m, %n] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32>
+
+    %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<128x256xi32> -> vector<128x256xi32>
+
+    %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<4096x4096xi8> -> !xetile.tile<128x256xi8>
+    %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<4096x4096xi8> -> !xetile.tile<256x256xi8>
+
+
+    //CHECK: %[[r9:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c4096]] step %[[c256]]
+    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[r6]], %[[arg5:.*]] = %[[r7]], %[[arg6:.*]] = %[[r8]])
+    //CHECK-SAME: !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
+    //CHECK-SAME: !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<16x16x8x16xi32>
+    %out:3 = scf.for %k = %c0 to %c4096 step %c256 iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
+                                                          -> (!xetile.tile<128x256xi8>, !xetile.tile<256x256xi8>, vector<128x256xi32>) {
+
+      //CHECK: %[[r10:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<4x8x32x32xi8>
+      //CHECK: %[[r11:.*]] = xetile.tile_unpack %[[r10]] {inner_blocks = array<i64: 32, 32>} : vector<4x8x32x32xi8> -> vector<128x256xi8>
+      %a_value = xetile.load_tile %a_tile : !xetile.tile<128x256xi8> -> vector<128x256xi8>
+
+      //CHECK: %[[r12:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<8x16x32x16xi8>
+      %b_value = xetile.load_tile %b_tile : !xetile.tile<256x256xi8> -> vector<256x256xi8>
+
+      //CHECK: %[[r13:.*]] = xetile.tile_pack %[[r11]] {inner_blocks = array<i64: 8, 32>} : vector<128x256xi8> -> vector<16x8x8x32xi8>
+      //CHECK: %[[r14:.*]] = xetile.tile_mma %[[r13]], %[[r12]], %[[arg6]] : vector<16x8x8x32xi8>, vector<8x16x32x16xi8>, vector<16x16x8x16xi32> -> vector<16x16x8x16xi32>
+      %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value
+        : vector<128x256xi8>, vector<256x256xi8>, vector<128x256xi32> -> vector<128x256xi32>
+
+      //CHECK: %[[r15:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c256]]] : !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>, index, index -> !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
+      //CHECK: %[[r16:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c256]],  %[[c0]]] : !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index -> !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
+      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c256] : !xetile.tile<128x256xi8>, index, index -> !xetile.tile<128x256xi8>
+      %b_next_tile = xetile.update_tile_offset %b_tile, [%c256, %c0] : !xetile.tile<256x256xi8>, index, index -> !xetile.tile<256x256xi8>
+
+      //CHECK: scf.yield %[[r15]], %[[r16]], %[[r14]] : !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>, !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<16x16x8x16xi32>
+      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<128x256xi8>, !xetile.tile<256x256xi8>, vector<128x256xi32>
+    }
+
+    //CHECK: xetile.store_tile %[[r9]]#2,  %[[r2]] : vector<16x16x8x16xi32>, !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+    xetile.store_tile %out#2, %c_init_tile : vector<128x256xi32>, !xetile.tile<128x256xi32>
+    gpu.return
+  }
+}
diff --git a/test/Dialect/XeTile/Transforms/Blocking/unit_tests.mlir b/test/Dialect/XeTile/Transforms/Blocking/unit_tests.mlir
index 05dc5cb1a..2ef8aca4b 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/unit_tests.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/unit_tests.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --new-xetile-blocking --canonicalize %s -verify-diagnostics -o -| FileCheck %s
+// RUN: imex-opt --split-input-file --xetile-blocking --canonicalize %s -verify-diagnostics -o -| FileCheck %s
 
 gpu.module @test_kernel {
   //CHECK: gpu.func @sg_load_tile(%[[arg0:.*]]: memref<32x32xf16>)
@@ -97,6 +97,21 @@ gpu.module @test_kernel {
   	gpu.return
   }
 
+  ///-CHECK: gpu.func @tile_mma_irregular(%[[arg0:.*]]: memref<128x128xf16>, %[[arg1:.*]]: memref<128x128xf16>)
+  ///-CHECK: %[[c0:.*]] = arith.constant 0 : index
+  ///-CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x128xf16> -> !xetile.tile<90x76xf16, #xetile.tile_attr<inner_blocks = [30, 19]>>
+  ///-CHECK: %[[R1:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x128xf16> -> !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1], inner_blocks = [19, 6]>>
+  ///-  gpu.func @tile_mma_irregular(%a: memref<128x128xf16>, %b: memref<128x128xf16>) {
+  ///-    %c0 = arith.constant 0 : index
+  ///-    %1 = xetile.init_tile %a[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<90x76xf16>
+  ///-    %2 = xetile.init_tile %b[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1]>>
+  ///-    %3 = xetile.load_tile %1 : !xetile.tile<90x76xf16> -> vector<90x76xf16>
+  ///-    %4 = xetile.load_tile %2 : !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1]>> -> vector<76x90xf16>
+  ///-    %5 = xetile.tile_mma %3, %4: vector<90x76xf16>, vector<76x90xf16> -> vector<90x90xf32>
+  ///-    gpu.return
+  ///-  }
+
+
   //CHECK: gpu.func @sg_gemm(%[[arg0:.*]]: memref<32x128xf16>, %[[arg1:.*]]: memref<128x32xf16>, %[[arg2:.*]]: memref<32x32xf32>)
   gpu.func @sg_gemm(%a: memref<32x128xf16>, %b: memref<128x32xf16>, %c: memref<32x32xf32>) {
     //CHECK: %[[c0:.*]] = arith.constant 0 : index
@@ -357,6 +372,73 @@ gpu.module @test_kernel {
     gpu.return
   }
 
+  //CHECK: (%[[arg0:.*]]: memref<1024x1024xf16>)
+  gpu.func @sglevel_softmax_dim_1(%a: memref<1024x1024xf16>) {
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
+    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
+
+    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
+    //CHECK: %[[r2:.*]] = xetile.tile_unpack %[[r1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
+    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
+
+    //CHECK: %[[r3:.*]] = xetile.tile_pack %[[r2]] {inner_blocks = array<i64: 8, 32>} : vector<32x64xf16> -> vector<4x2x8x32xf16>
+    //CHECK: %[[r4:.*]] = math.exp %[[r3]] : vector<4x2x8x32xf16>
+    %3 = math.exp %2: vector<32x64xf16>
+
+    //CHECK: %[[r5:.*]] = xetile.tile_unpack %[[r4]] {inner_blocks = array<i64: 8, 32>} : vector<4x2x8x32xf16> -> vector<32x64xf16>
+    //CHECK: %[[r6:.*]] = xetile.tile_pack %[[r5]] {inner_blocks = array<i64: 1, 32>} : vector<32x64xf16> -> vector<32x2x1x32xf16>
+    //CHECK: %[[r7:.*]] = xetile.reduction <add>, %[[r6]] [1, 3] : vector<32x2x1x32xf16> -> vector<32x1x1x1xf16>
+    %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
+    //CHECK: %[[r8:.*]] = xetile.broadcast %[[r7]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x2x1x32xf16>
+    //CHECK: %[[r9:.*]] = xetile.tile_unpack %[[r8]] {inner_blocks = array<i64: 1, 32>} : vector<32x2x1x32xf16> -> vector<32x64xf16>
+    %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
+
+    //CHECK: %[[r10:.*]] = xetile.tile_pack %[[r9]] {inner_blocks = array<i64: 8, 32>} : vector<32x64xf16> -> vector<4x2x8x32xf16>
+    //CHECK: %[[r11:.*]] = arith.divf %[[r4]], %[[r10]] : vector<4x2x8x32xf16>
+    %6 = arith.divf %3, %5: vector<32x64xf16>
+    //CHECK: %[[r12:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+    %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
+    //CHECK: xetile.store_tile %[[r11]],  %[[r12]] : vector<4x2x8x32xf16>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+    xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
+    gpu.return
+  }
+
+  //CHECK-LABEL: gpu.func @sglevel_softmax_transpose
+  //CHECK-SAME(%[[arg0:.*]]: memref<1024x1024xf16>)
+  gpu.func @sglevel_softmax_transpose(%a: memref<1024x1024xf16>) {
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 8]>>
+    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
+
+    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 8]>> -> vector<1x8x32x8xf16>
+    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
+
+    //CHECK: %[[r2:.*]] = math.exp %[[r1]] : vector<1x8x32x8xf16>
+    //CHECK: %[[r3:.*]] = xetile.tile_unpack %[[r2]] {inner_blocks = array<i64: 32, 8>} : vector<1x8x32x8xf16> -> vector<32x64xf16>
+    %3 = math.exp %2: vector<32x64xf16>
+
+    //CHECK: %[[r4:.*]] = xetile.tile_pack %[[r3]] {inner_blocks = array<i64: 1, 32>} : vector<32x64xf16> -> vector<32x2x1x32xf16>
+    //CHECK: %[[r5:.*]] = xetile.reduction <add>, %[[r4]] [1, 3] : vector<32x2x1x32xf16> -> vector<32x1x1x1xf16>
+    %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
+
+    //CHECK: %[[r6:.*]] = xetile.broadcast %[[r5]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x8x1x8xf16>
+    //CHECK: %[[r7:.*]] = xetile.tile_unpack %[[r6]] {inner_blocks = array<i64: 1, 8>} : vector<32x8x1x8xf16> -> vector<32x64xf16>
+    %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
+
+    //CHECK: %[[r8:.*]] = xetile.tile_pack %[[r7]] {inner_blocks = array<i64: 32, 8>} : vector<32x64xf16> -> vector<1x8x32x8xf16>
+    //CHECK: %[[r9:.*]] = arith.divf %[[r2]], %[[r8]] : vector<1x8x32x8xf16>
+    %6 = arith.divf %3, %5: vector<32x64xf16>
+
+    //CHECK: %[[r10:.*]] = xetile.transpose %[[r9]], [1, 0, 3, 2] : vector<1x8x32x8xf16> -> vector<8x1x8x32xf16>
+    %7 = xetile.transpose %6, [1, 0]: vector<32x64xf16> -> vector<64x32xf16>
+
+    //CHECK: %[[r11:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+    %8 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16>
+
+    //CHECK: xetile.store_tile %[[r10]],  %[[r11]] : vector<8x1x8x32xf16>, !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+    xetile.store_tile %7, %8: vector<64x32xf16>, !xetile.tile<64x32xf16>
+    gpu.return
+  }
+
   gpu.func @sglevel_unregular_gemm(%arg0: memref<16384x12288xf16>, %arg1: memref<1536x12288xf16>, %arg2: memref<16384x1536xf32>) attributes {gemm_tiles_b = 1 : i64, gemm_tiles_x = dense<[8, 2, 4, 8]> : vector<4xi64>, gemm_tiles_y = dense<[1, 1, 8, 4]> : vector<4xi64>, physical_nd_range = dense<[8, 32]> : vector<2xi64>, region_partition = 0 : i64, region_size = 32 : i64, syn.fusion_successful, syn.tensor_signature = (tensor<16384x12288xf16>, tensor<1536x12288xf16>) -> tensor<16384x1536xf32>, synFusionGenOps = 6 : i64, synFusionRequiredBeamSize = 1 : i64, synFusionTotalCost = 1007562515.4 : f64} {
     %c64 = arith.constant 64 : index
     %cst = arith.constant dense<0.000000e+00> : vector<32x64xf32>
diff --git a/test/Dialect/XeTile/Transforms/blocking.mlir b/test/Dialect/XeTile/Transforms/blocking.mlir
deleted file mode 100644
index 0526535e5..000000000
--- a/test/Dialect/XeTile/Transforms/blocking.mlir
+++ /dev/null
@@ -1,412 +0,0 @@
-// RUN: imex-opt --split-input-file --xetile-blocking %s -verify-diagnostics -o -| FileCheck %s
-
-gpu.module @test_kernel {
-  //CHECK: gpu.func @sg_load_tile(%[[arg0:.*]]: memref<32x32xf16>)
-  //CHECK: %[[c0:.*]] = arith.constant 0 : index
-  //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
-  //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x1x32x32xf16>
-  //CHECK: gpu.return
-  gpu.func @sg_load_tile(%a: memref<32x32xf16>) {
-    %c0 = arith.constant 0 : index
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-    %2 = xetile.load_tile %1 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-  	gpu.return
-  }
-
-  //CHECK: gpu.func @sg_tiled_store(%[[arg0:.*]]: memref<32x32xf32>)
-  //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<1x2x32x16xf32>
-  //CHECK: %[[R0:.*]] = xetile.tile_unpack %[[cst]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf32> -> vector<32x32xf32>
-  //CHECK: %[[R1:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<32x32xf32> -> !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-  //CHECK: %[[R2:.*]] = xetile.tile_pack %[[R0]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf32> -> vector<4x2x8x16xf32>
-  //CHECK: xetile.store_tile %[[R2]],  %[[R1]] : vector<4x2x8x16xf32>, !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-  //CHECK: gpu.return
-	gpu.func @sg_tiled_store(%a: memref<32x32xf32>) {
-		%result = arith.constant dense<0.0>: vector<32x32xf32>
-		%1 = xetile.init_tile %a[0, 0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
-		xetile.store_tile %result, %1: vector<32x32xf32>, !xetile.tile<32x32xf32>
-		gpu.return
-	}
-
-  //CHECK: gpu.func @sg_tile_mma(%[[arg0:.*]]: memref<32x32xf16>, %[[arg1:.*]]: memref<32x32xf16>)
-  gpu.func @sg_tile_mma(%a: memref<32x32xf16>, %b: memref<32x32xf16>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    %c0 = arith.constant 0 : index
-
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-    //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-    %2 = xetile.load_tile %1 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-    //CHECK: %[[R3:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<32x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-  	%3 = xetile.init_tile %b[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK: %[[R4:.*]] = xetile.load_tile %[[R3]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-    //CHECK: %[[R5:.*]] = xetile.tile_unpack %[[R4]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-    %4 = xetile.load_tile %3 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-    //CHECK: %[[R6:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf16> -> vector<4x2x8x16xf16>
-    //CHECK: %[[R7:.*]] = xetile.tile_pack %[[R5]] {inner_blocks = array<i64: 16, 16>}  : vector<32x32xf16> -> vector<2x2x16x16xf16>
-    //CHECK: %[[R8:.*]] = xetile.tile_mma %[[R6]], %[[R7]] : vector<4x2x8x16xf16>, vector<2x2x16x16xf16> -> vector<4x2x8x16xf32>
-    %5 = xetile.tile_mma %2, %4: vector<32x32xf16>, vector<32x32xf16> -> vector<32x32xf32>
-
-    //CHECK: gpu.return
-  	gpu.return
-  }
-
-  //CHECK: gpu.func @sg_gemm(%[[arg0:.*]]: memref<32x128xf16>, %[[arg1:.*]]: memref<128x32xf16>, %[[arg2:.*]]: memref<32x32xf32>)
-  gpu.func @sg_gemm(%a: memref<32x128xf16>, %b: memref<128x32xf16>, %c: memref<32x32xf32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    %c0 = arith.constant 0 : index
-
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    %c32 = arith.constant 32 : index
-
-    //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    %c128 = arith.constant 128 : index
-
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<4x2x8x16xf32>
-    %cst = arith.constant dense<0.0>: vector<32x32xf32>
-
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x128xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x128xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK: %[[R1:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-  	%2 = xetile.init_tile %b[%c0, %c0] : memref<128x32xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK: %[[R2:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c128]] step %[[c32]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[R0]], %[[arg5:.*]] = %[[R1]], %[[arg6:.*]] = %[[cst]])
-    //CHECK-SAME: !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>,
-    //CHECK-SAME: !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x2x8x16xf32>
-    %out:3 = scf.for %k = %c0 to %c128 step %c32 iter_args(%a_tile = %1, %b_tile = %2, %c_value = %cst)
-        -> (!xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>) {
-      //CHECK: %[[R8:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-      //CHECK: %[[R9:.*]] = xetile.tile_unpack %[[R8]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-      %3 = xetile.load_tile %a_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-      //CHECK: %[[R10:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-      //CHECK: %[[R11:.*]] = xetile.tile_unpack %[[R10]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-      %4 = xetile.load_tile %b_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-      //CHECK: %[[R12:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c32]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c32]: !xetile.tile<32x32xf16>, index, index -> !xetile.tile<32x32xf16>
-
-      //CHECK: %[[R13:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c32]],  %[[c0]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %b_next_tile = xetile.update_tile_offset %b_tile, [%c32, %c0]: !xetile.tile<32x32xf16>, index, index -> !xetile.tile<32x32xf16>
-
-      //CHECK: %[[R14:.*]] = xetile.tile_pack %[[R9]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf16> -> vector<4x2x8x16xf16>
-      //CHECK: %[[R15:.*]] = xetile.tile_pack %[[R11]] {inner_blocks = array<i64: 16, 16>}  : vector<32x32xf16> -> vector<2x2x16x16xf16>
-      //CHECK: %[[R16:.*]] = xetile.tile_mma %[[R14]], %[[R15]], %[[arg6]] : vector<4x2x8x16xf16>, vector<2x2x16x16xf16>, vector<4x2x8x16xf32> -> vector<4x2x8x16xf32>
-      %c_new_value = xetile.tile_mma %3, %4, %c_value:
-        vector<32x32xf16>, vector<32x32xf16>, vector<32x32xf32> -> vector<32x32xf32>
-
-      //CHECK: scf.yield %[[R12]], %[[R13]], %[[R16]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x2x8x16xf32>
-      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>
-    }
-
-    //CHECK: %[[REG6:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-  	%c_tile = xetile.init_tile %c[%c0, %c0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
-
-    //CHECK: xetile.store_tile %[[R2]]#2,  %[[REG6]] : vector<4x2x8x16xf32>, !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    xetile.store_tile %out#2, %c_tile: vector<32x32xf32>, !xetile.tile<32x32xf32>
-
-    //CHECK: gpu.return
-  	gpu.return
-  }
-
-    //CHECK: gpu.func @load_tile(%[[arg0:.*]]: memref<128x128xf16>)
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x128xf16> -> !xetile.tile<85x76xf16, #xetile.tile_attr<inner_blocks = [17, 19]>>
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<85x76xf16, #xetile.tile_attr<inner_blocks = [17, 19]>> -> vector<5x4x17x19xf16>
-    //CHECK: gpu.return
-    gpu.func @load_tile(%a: memref<128x128xf16>) {
-      %c0 = arith.constant 0 : index
-  	  %1 = xetile.init_tile %a[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<85x76xf16>
-      %2 = xetile.load_tile %1 : !xetile.tile<85x76xf16> -> vector<85x76xf16>
-  	  gpu.return
-    }
-
-    //CHECK: gpu.func @store_tile(%[[arg0:.*]]: memref<128x128xf32>)
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<2x19x22x2xf32>
-    //CHECK: %[[R0:.*]] = xetile.tile_unpack %[[cst]] {inner_blocks = array<i64: 22, 2>}  : vector<2x19x22x2xf32> -> vector<44x38xf32>
-    //CHECK: %[[R1:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<128x128xf32> -> !xetile.tile<44x38xf32, #xetile.tile_attr<inner_blocks = [4, 2]>>
-    //CHECK: %[[R2:.*]] = xetile.tile_pack %[[R0]] {inner_blocks = array<i64: 4, 2>}  : vector<44x38xf32> -> vector<11x19x4x2xf32>
-    //CHECK: xetile.store_tile %[[R2]],  %[[R1]] : vector<11x19x4x2xf32>, !xetile.tile<44x38xf32, #xetile.tile_attr<inner_blocks = [4, 2]>>
-    //CHECK: gpu.return
-	  gpu.func @store_tile(%a: memref<128x128xf32>) {
-		  %result = arith.constant dense<0.0>: vector<44x38xf32>
-		  %1 = xetile.init_tile %a[0, 0] : memref<128x128xf32> -> !xetile.tile<44x38xf32>
-		  xetile.store_tile %result, %1: vector<44x38xf32>, !xetile.tile<44x38xf32>
-		  gpu.return
-	  }
-
-    //CHECK: gpu.func @create_mask
-    //CHECK-DAG: %[[C20:.*]] = arith.constant 20
-    //CHECK-DAG: %[[C32:.*]] = arith.constant 32
-    //CHECK: %[[MASK:.*]] = vector.create_mask %[[C32]], %[[C20]], %[[C32]], %[[C20]] : vector<32x1x1x32xi1>
-    //CHECK: arith.select %[[MASK]], {{.*}} : vector<32x1x1x32xi1>, vector<32x1x1x32xf16>
-    gpu.func @create_mask(%a: vector<32x32xf16>, %b: vector<32x32xf16>, %c: memref<32x32xf16>) {
-      %c32 = arith.constant 32 : index
-      %c20 = arith.constant 20 : index
-      %mask = vector.create_mask %c32, %c20 : vector<32x32xi1>
-      %select = arith.select %mask, %a, %b : vector<32x32xi1>, vector<32x32xf16>
-      %tile = xetile.init_tile %c[0, 0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-      xetile.store_tile %select, %tile: vector<32x32xf16>, !xetile.tile<32x32xf16>
-      gpu.return
-    }
-
-    //CHECK: gpu.func @create_mask_2
-    //CHECK-DAG: %[[C20:.*]] = arith.constant 20
-    //CHECK-DAG: %[[C32:.*]] = arith.constant 32
-    //CHECK: %[[MASK:.*]] = vector.create_mask %[[C20]], %[[C32]], %[[C20]], %[[C32]] : vector<32x1x1x32xi1>
-    //CHECK: arith.select %[[MASK]], {{.*}} : vector<32x1x1x32xi1>, vector<32x1x1x32xf16>
-    gpu.func @create_mask_2(%a: vector<32x32xf16>, %b: vector<32x32xf16>, %c: memref<32x32xf16>) {
-      %c20 = arith.constant 20 : index
-      %c32 = arith.constant 32 : index
-      %mask = vector.create_mask %c20, %c32 : vector<32x32xi1>
-      %select = arith.select %mask, %a, %b : vector<32x32xi1>, vector<32x32xf16>
-      %tile = xetile.init_tile %c[0, 0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-      xetile.store_tile %select, %tile: vector<32x32xf16>, !xetile.tile<32x32xf16>
-      gpu.return
-    }
-
-    ///-CHECK: gpu.func @tile_mma(%[[arg0:.*]]: memref<128x128xf16>, %[[arg1:.*]]: memref<128x128xf16>)
-    ///-CHECK: %[[c0:.*]] = arith.constant 0 : index
-    ///-CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x128xf16> -> !xetile.tile<90x76xf16, #xetile.tile_attr<inner_blocks = [30, 19]>>
-    ///-CHECK: %[[R1:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x128xf16> -> !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1], inner_blocks = [19, 6]>>
-    ///-  gpu.func @tile_mma(%a: memref<128x128xf16>, %b: memref<128x128xf16>) {
-    ///-    %c0 = arith.constant 0 : index
-  	///-    %1 = xetile.init_tile %a[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<90x76xf16>
-    ///-    %2 = xetile.init_tile %b[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1]>>
-    ///-    %3 = xetile.load_tile %1 : !xetile.tile<90x76xf16> -> vector<90x76xf16>
-    ///-    %4 = xetile.load_tile %2 : !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1]>> -> vector<76x90xf16>
-    ///-    %5 = xetile.tile_mma %3, %4: vector<90x76xf16>, vector<76x90xf16> -> vector<90x90xf32>
-  	///-    gpu.return
-    ///-  }
-
-    // CHECK-LABEL: gpu.func @inner_reduction
-    // CHECK-SAME: (%[[arg0:.*]]: memref<128x256xf16>, %[[arg1:.*]]: memref<128x256xf16>)
-    gpu.func @inner_reduction(%a: memref<128x256xf16>, %b: memref<128x256xf16>) {
-      // CHECK: %[[c0:.*]] = arith.constant 0 : index
-      // CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<16xf16>
-      %c0 = arith.constant 0 : index
-      %acc = arith.constant dense<0.0> : vector<16xf16>
-      // CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<16x32xf16, #xetile.tile_attr<inner_blocks = [16, 32]>>
-      %t = xetile.init_tile %a[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-      // CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<16x32xf16, #xetile.tile_attr<inner_blocks = [16, 32]>> -> vector<1x1x16x32xf16>
-      // CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 16, 32>}  : vector<1x1x16x32xf16> -> vector<16x32xf16>
-      %v = xetile.load_tile %t : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-      // CHECK: %[[R3:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 1, 32>}  : vector<16x32xf16> -> vector<16x1x1x32xf16>
-      // CHECK: %[[R4:.*]] = math.exp %[[R3]] : vector<16x1x1x32xf16>
-      %e = math.exp %v: vector<16x32xf16>
-      // CHECK: %[[R5:.*]] = vector.shape_cast %[[cst]] : vector<16xf16> to vector<16x1xf16>
-      // CHECK: %[[R6:.*]] = vector.multi_reduction <add>, %[[R4]], %[[R5]] [1, 3] : vector<16x1x1x32xf16> to vector<16x1xf16>
-      // CHECK: %[[R7:.*]] = vector.shape_cast %[[R6]] : vector<16x1xf16> to vector<16xf16>
-      %r = vector.multi_reduction <add>, %e, %acc [1] : vector<16x32xf16> to vector<16xf16>
-      // CHECK: %[[R8:.*]] = vector.shape_cast %[[R7]] : vector<16xf16> to vector<2x8xf16>
-      %c = vector.shape_cast %r: vector<16xf16> to vector<2x8xf16>
-      // CHECK: %[[R9:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<2x8xf16, #xetile.tile_attr<inner_blocks = [2, 8]>>
-      %s = xetile.init_tile %b[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<2x8xf16>
-      // CHECK: %[[R10:.*]] = xetile.tile_pack %[[R8]] {inner_blocks = array<i64: 2, 8>}  : vector<2x8xf16> -> vector<1x1x2x8xf16>
-      // CHECK: xetile.store_tile %[[R10]],  %[[R9]] : vector<1x1x2x8xf16>, !xetile.tile<2x8xf16, #xetile.tile_attr<inner_blocks = [2, 8]>>
-      xetile.store_tile %c, %s : vector<2x8xf16>, !xetile.tile<2x8xf16>
-      gpu.return
-    }
-
-    //CHECK: gpu.func @outter_reduction(%[[arg0:.*]]: memref<128x256xf16>, %[[arg1:.*]]: memref<128x256xf16>) {
-    gpu.func @outter_reduction(%a: memref<128x256xf16>, %b: memref<128x256xf16>) {
-      //CHECK: %[[c0:.*]] = arith.constant 0 : index
-      //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<32xf16>
-      %c0 = arith.constant 0 : index
-      %acc = arith.constant dense<0.0> : vector<32xf16>
-      //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<16x32xf16, #xetile.tile_attr<inner_blocks = [16, 32]>>
-      %t = xetile.init_tile %a[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-      //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<16x32xf16, #xetile.tile_attr<inner_blocks = [16, 32]>> -> vector<1x1x16x32xf16>
-      //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 16, 32>}  : vector<1x1x16x32xf16> -> vector<16x32xf16>
-      %v = xetile.load_tile %t : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-      //CHECK: %[[R3:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 1, 32>}  : vector<16x32xf16> -> vector<16x1x1x32xf16>
-      //CHECK: %[[R4:.*]] = math.exp %[[R3]] : vector<16x1x1x32xf16>
-      %e = math.exp %v: vector<16x32xf16>
-      //CHECK: %[[R5:.*]] = vector.shape_cast %[[cst]] : vector<32xf16> to vector<1x32xf16>
-      //CHECK: %[[R6:.*]] = vector.multi_reduction <add>, %[[R4]], %[[R5]] [0, 2] : vector<16x1x1x32xf16> to vector<1x32xf16>
-      //CHECK: %[[R7:.*]] = vector.shape_cast %[[R6]] : vector<1x32xf16> to vector<32xf16>
-      %r = vector.multi_reduction <add>, %e, %acc [0] : vector<16x32xf16> to vector<32xf16>
-      //CHECK: %[[R8:.*]] = vector.shape_cast %[[R7]] : vector<32xf16> to vector<4x8xf16>
-      %c = vector.shape_cast %r: vector<32xf16> to vector<4x8xf16>
-      //CHECK: %[[R9:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<4x8xf16, #xetile.tile_attr<inner_blocks = [4, 8]>>
-      %s = xetile.init_tile %b[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<4x8xf16>
-      //CHECK: %[[R10:.*]] = xetile.tile_pack %[[R8]] {inner_blocks = array<i64: 4, 8>}  : vector<4x8xf16> -> vector<1x1x4x8xf16>
-      //CHECK: xetile.store_tile %[[R10]],  %[[R9]] : vector<1x1x4x8xf16>, !xetile.tile<4x8xf16, #xetile.tile_attr<inner_blocks = [4, 8]>>
-      xetile.store_tile %c, %s : vector<4x8xf16>, !xetile.tile<4x8xf16>
-      gpu.return
-    }
-
-  //CHECK-LABEL: gpu.func @sg_gemm_with_preops_for_c
-  //CHECK-SAME: (%[[arg0:.*]]: memref<32x128xf16>, %[[arg1:.*]]: memref<128x32xf16>, %[[arg2:.*]]: memref<32x32xf32>)
-  gpu.func @sg_gemm_with_preops_for_c(%a: memref<32x128xf16>, %b: memref<128x32xf16>, %c: memref<32x32xf32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<1x2x32x16xf32>
-    %c0 = arith.constant 0 : index
-    %c32 = arith.constant 32 : index
-    %c128 = arith.constant 128 : index
-    %cst = arith.constant dense<0.0>: vector<32x32xf32>
-
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x128xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x128xf16> -> !xetile.tile<32x32xf16>
-  	%2 = xetile.init_tile %b[%c0, %c0] : memref<128x32xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r2:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c128]] step %[[c32]] iter_args(%[[arg4:.*]] = %[[r0]], %[[arg5:.*]] = %[[r1]], %[[arg6]] = %[[cst]]) -> (!xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<1x2x32x16xf32>) {
-    %out:3 = scf.for %k = %c0 to %c128 step %c32 iter_args(%a_tile = %1, %b_tile = %2, %c_value = %cst)
-        -> (!xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>) {
-      //CHECK: %[[r6:.*]] = xetile.tile_unpack %[[arg6]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf32> -> vector<32x32xf32>
-
-      //CHECK: %[[r7:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-      //CHECK: %[[r8:.*]] = xetile.tile_unpack %[[r7]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-      %3 = xetile.load_tile %a_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-      //CHECK: %[[r9:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-      //CHECK: %[[r10:.*]] = xetile.tile_unpack %[[r9]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-      %4 = xetile.load_tile %b_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-      //CHECK: %[[r11:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c32]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK: %[[r12:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c32]],  %[[c0]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c32]: !xetile.tile<32x32xf16>, index, index -> !xetile.tile<32x32xf16>
-      %b_next_tile = xetile.update_tile_offset %b_tile, [%c32, %c0]: !xetile.tile<32x32xf16>, index, index -> !xetile.tile<32x32xf16>
-
-      //CHECK: %[[r13:.*]] = xetile.tile_pack %[[r6]] {inner_blocks = array<i64: 1, 16>}  : vector<32x32xf32> -> vector<32x2x1x16xf32>
-      //CHECK: %[[r14:.*]] = xetile.tile_pack %[[r6]] {inner_blocks = array<i64: 1, 16>}  : vector<32x32xf32> -> vector<32x2x1x16xf32>
-      //CHECK: %[[r15:.*]] = arith.addf %[[r13]], %[[r14]] : vector<32x2x1x16xf32>
-      %5 = arith.addf %c_value, %c_value: vector<32x32xf32>
-
-      //CHECK: %[[r16:.*]] = xetile.tile_unpack %[[r15]] {inner_blocks = array<i64: 1, 16>}  : vector<32x2x1x16xf32> -> vector<32x32xf32>
-      //CHECK: %[[r17:.*]] = xetile.tile_pack %[[r8]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf16> -> vector<4x2x8x16xf16>
-      //CHECK: %[[r18:.*]] = xetile.tile_pack %[[r10]] {inner_blocks = array<i64: 16, 16>}  : vector<32x32xf16> -> vector<2x2x16x16xf16>
-      //CHECK: %[[r19:.*]] = xetile.tile_pack %[[r16]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf32> -> vector<4x2x8x16xf32>
-      //CHECK: %[[r20:.*]] = xetile.tile_mma %[[r17]], %[[r18]], %[[r19]] : vector<4x2x8x16xf16>, vector<2x2x16x16xf16>, vector<4x2x8x16xf32> -> vector<4x2x8x16xf32>
-      %c_new_value = xetile.tile_mma %3, %4, %5: vector<32x32xf16>, vector<32x32xf16>, vector<32x32xf32> -> vector<32x32xf32>
-      //CHECK: %[[r21:.*]] = xetile.tile_unpack %[[r20]] {inner_blocks = array<i64: 8, 16>}  : vector<4x2x8x16xf32> -> vector<32x32xf32>
-      //CHECK: %[[r22:.*]] = xetile.tile_pack %[[r21]] {inner_blocks = array<i64: 32, 16>}  : vector<32x32xf32> -> vector<1x2x32x16xf32>
-      //CHECK: scf.yield %[[r11]], %[[r12]], %[[r22]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<1x2x32x16xf32>
-      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>
-    }
-
-    //CHECK: %[[r3:.*]] = xetile.tile_unpack %[[r2]]#2 {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf32> -> vector<32x32xf32>
-    //CHECK: %[[r4:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-  	%c_tile = xetile.init_tile %c[%c0, %c0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
-
-    //CHECK: %[[r5:.*]] = xetile.tile_pack %[[r3]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf32> -> vector<4x2x8x16xf32>
-    //CHECK: xetile.store_tile %[[r5]],  %[[r4]] : vector<4x2x8x16xf32>, !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    xetile.store_tile %out#2, %c_tile: vector<32x32xf32>, !xetile.tile<32x32xf32>
-  	gpu.return
-  }
-
-    //CHECK-LABEL: gpu.func @sglevel_softmax_dim_0
-    //CHECK-SAME: (%[[arg0:.*]]: memref<1024x1024xf16>)
-    gpu.func @sglevel_softmax_dim_0(%a: memref<1024x1024xf16>) {
-      //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-
-      //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
-      //CHECK: %[[r2:.*]] = xetile.tile_unpack %[[r1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
-      %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-
-      //CHECK: %[[r3:.*]] = xetile.tile_pack %[[r2]] {inner_blocks = array<i64: 1, 32>}  : vector<32x64xf16> -> vector<32x2x1x32xf16>
-      //CHECK: %[[r4:.*]] = math.exp %[[r3]] : vector<32x2x1x32xf16>
-      %3 = math.exp %2: vector<32x64xf16>
-
-      //CHECK: %[[r5:.*]] = xetile.reduction <add>, %[[r4]] [0, 2] : vector<32x2x1x32xf16> -> vector<1x2x1x32xf16>
-      %4 = xetile.reduction <add>, %3 [0]: vector<32x64xf16> -> vector<1x64xf16>
-
-      //CHECK: %[[r6:.*]] = xetile.broadcast %[[r5]] [0, 2] : vector<1x2x1x32xf16> -> vector<32x2x1x32xf16>
-      %5 = xetile.broadcast %4 [0]: vector<1x64xf16> -> vector<32x64xf16>
-
-      //CHECK: %[[r7:.*]] = arith.divf %[[r4]], %[[r6]] : vector<32x2x1x32xf16>
-      //CHECK: %[[r8:.*]] = xetile.tile_unpack %[[r7]] {inner_blocks = array<i64: 1, 32>}  : vector<32x2x1x32xf16> -> vector<32x64xf16>
-      %6 = arith.divf %3, %5: vector<32x64xf16>
-
-      //CHECK: %[[r9:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-      %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-
-      //CHECK: %[[r10:.*]] = xetile.tile_pack %[[r8]] {inner_blocks = array<i64: 8, 32>}  : vector<32x64xf16> -> vector<4x2x8x32xf16>
-      //CHECK: xetile.store_tile %[[r10]],  %[[r9]] : vector<4x2x8x32xf16>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-      xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
-      gpu.return
-    }
-
-
-    //CHECK-LABEL: gpu.func @sglevel_softmax_dim_1
-    //CHECK-SAME: (%[[arg0:.*]]: memref<1024x1024xf16>)
-    gpu.func @sglevel_softmax_dim_1(%a: memref<1024x1024xf16>) {
-      //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-
-      //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
-      //CHECK: %[[r2:.*]] = xetile.tile_unpack %[[r1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
-      %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-
-      //CHECK: %[[r3:.*]] = xetile.tile_pack %[[r2]] {inner_blocks = array<i64: 1, 32>}  : vector<32x64xf16> -> vector<32x2x1x32xf16>
-      //CHECK: %[[r4:.*]] = math.exp %[[r3]] : vector<32x2x1x32xf16>
-      %3 = math.exp %2: vector<32x64xf16>
-
-      //CHECK: %[[r5:.*]] = xetile.reduction <add>, %[[r4]] [1, 3] : vector<32x2x1x32xf16> -> vector<32x1x1x1xf16>
-      %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
-
-      //CHECK: %[[r6:.*]] = xetile.broadcast %[[r5]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x2x1x32xf16>
-      %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
-
-      //CHECK: %[[r7:.*]] = arith.divf %[[r4]], %[[r6]] : vector<32x2x1x32xf16>
-      //CHECK: %[[r8:.*]] = xetile.tile_unpack %[[r7]] {inner_blocks = array<i64: 1, 32>}  : vector<32x2x1x32xf16> -> vector<32x64xf16>
-      %6 = arith.divf %3, %5: vector<32x64xf16>
-
-      //CHECK: %[[r9:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-      %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-
-      //CHECK: %[[r10:.*]] = xetile.tile_pack %[[r8]] {inner_blocks = array<i64: 8, 32>}  : vector<32x64xf16> -> vector<4x2x8x32xf16>
-      //CHECK: xetile.store_tile %[[r10]],  %[[r9]] : vector<4x2x8x32xf16>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-      xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
-      gpu.return
-    }
-
-
-    //CHECK-LABEL: gpu.func @sglevel_softmax_transpose
-    //CHECK-SAME(%[[arg0:.*]]: memref<1024x1024xf16>)
-    gpu.func @sglevel_softmax_transpose(%a: memref<1024x1024xf16>) {
-      //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-
-      //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
-      //CHECK: %[[r2:.*]] = xetile.tile_unpack %[[r1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
-      %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-
-      //CHECK: %[[r3:.*]] = xetile.tile_pack %[[r2]] {inner_blocks = array<i64: 1, 32>}  : vector<32x64xf16> -> vector<32x2x1x32xf16>
-      //CHECK: %[[r4:.*]] = math.exp %[[r3]] : vector<32x2x1x32xf16>
-      %3 = math.exp %2: vector<32x64xf16>
-
-      //CHECK: %[[r5:.*]] = xetile.reduction <add>, %[[r4]] [1, 3] : vector<32x2x1x32xf16> -> vector<32x1x1x1xf16>
-      %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
-
-      //CHECK: %[[r6:.*]] = xetile.broadcast %[[r5]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x2x1x32xf16>
-      %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
-
-      //CHECK: %[[r7:.*]] = arith.divf %[[r4]], %[[r6]] : vector<32x2x1x32xf16>
-      //CHECK: %[[r8:.*]] = xetile.tile_unpack %[[r7]] {inner_blocks = array<i64: 1, 32>}  : vector<32x2x1x32xf16> -> vector<32x64xf16>
-      %6 = arith.divf %3, %5: vector<32x64xf16>
-
-      //CHECK: %[[r9:.*]] = xetile.tile_pack %[[r8]] {inner_blocks = array<i64: 8, 16>}  : vector<32x64xf16> -> vector<4x4x8x16xf16>
-      //CHECK: %[[r10:.*]] = xetile.transpose %[[r9]], [1, 0, 3, 2] : vector<4x4x8x16xf16> -> vector<4x4x16x8xf16>
-      //CHECK: %[[r11:.*]] = xetile.tile_unpack %[[r10]] {inner_blocks = array<i64: 16, 8>}  : vector<4x4x16x8xf16> -> vector<64x32xf16>
-      %7 = xetile.transpose %6, [1, 0]: vector<32x64xf16> -> vector<64x32xf16>
-
-      //CHECK: %[[r12:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-      %8 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16>
-
-      //CHECK: %[[r13:.*]] = xetile.tile_pack %[[r11]] {inner_blocks = array<i64: 8, 32>}  : vector<64x32xf16> -> vector<8x1x8x32xf16>
-      //CHECK: xetile.store_tile %[[r13]],  %[[r12]] : vector<8x1x8x32xf16>, !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-      xetile.store_tile %7, %8: vector<64x32xf16>, !xetile.tile<64x32xf16>
-      gpu.return
-    }
-
-}
diff --git a/test/Dialect/XeTile/Transforms/persistent_kernel.mlir b/test/Dialect/XeTile/Transforms/persistent_kernel.mlir
deleted file mode 100644
index fd821f56d..000000000
--- a/test/Dialect/XeTile/Transforms/persistent_kernel.mlir
+++ /dev/null
@@ -1,201 +0,0 @@
-// RUN:  imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking %s -verify-diagnostics -o -| FileCheck %s
-module @gemm attributes {gpu.container_module} {
-  gpu.module @test_kernel attributes {spirv.target_env = #spirv.target_env<#spirv.vce<v1.4, [Addresses, Float16Buffer, Int64, Int16, Int8, Kernel, Linkage, Vector16, GenericPointer, Groups, Float16, Float64, AtomicFloat32AddEXT, ExpectAssumeKHR, SubgroupDispatch, VectorComputeINTEL, VectorAnyINTEL], [SPV_EXT_shader_atomic_float_add, SPV_KHR_expect_assume, SPV_INTEL_vector_compute]>, api=OpenCL, #spirv.resource_limits<>>} {
-
-    //CHECK: gpu.func @test_kernel(%[[arg0:.*]]: memref<4096x4096xf16>, %[[arg1:.*]]: memref<4096x4096xf16>, %[[arg2:.*]]: memref<4096x4096xf32>) kernel attributes {VectorComputeFunctionINTEL, spirv.entry_point_abi = #spirv.entry_point_abi<>} {
-    gpu.func @test_kernel(%A: memref<4096x4096xf16>, %B: memref<4096x4096xf16>, %C: memref<4096x4096xf32>) kernel attributes {VectorComputeFunctionINTEL, spirv.entry_point_abi = #spirv.entry_point_abi<>} {
-      //CHECK: %[[c0_i8:.*]] = arith.constant 0 : i8
-      //CHECK: %[[c1_i8:.*]] = arith.constant 1 : i8
-      //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<4x4x8x16xf32>
-      //CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32
-      //CHECK: %[[c64:.*]] = arith.constant 64 : index
-      //CHECK: %[[c8:.*]] = arith.constant 8 : index
-      //CHECK: %[[c4:.*]] = arith.constant 4 : index
-      //CHECK: %[[c4096:.*]] = arith.constant 4096 : index
-      //CHECK: %[[c32:.*]] = arith.constant 32 : index
-      //CHECK: %[[c256:.*]] = arith.constant 256 : index
-      //CHECK: %[[c0:.*]] = arith.constant 0 : index
-      //CHECK: %[[c3:.*]] = arith.constant 3 : index
-      //CHECK: %[[c1:.*]] = arith.constant 1 : index
-      %c0_23 = arith.constant 0 : index
-      %c3 = arith.constant 3 : index
-      %c1_24 = arith.constant 1 : index
-      //CHECK: scf.for %[[arg3:.*]] = %[[c0]] to %[[c3]] step %[[c1]] {
-      scf.for %arg17 = %c0_23 to %c3 step %c1_24 {
-        %c256 = arith.constant 256 : index
-        %c512 = arith.constant 512 : index
-        %c128 = arith.constant 128 : index
-        %c32 = arith.constant 32 : index
-        %c4096 = arith.constant 4096 : index
-        %c4 = arith.constant 4 : index
-        %c8 = arith.constant 8 : index
-        %c64 = arith.constant 64 : index
-        %c1 = arith.constant 1 : index
-        %c48 = arith.constant 48 : index
-        %c16 = arith.constant 16 : index
-        %c24 = arith.constant 24 : index
-        %c0 = arith.constant 0 : index
-        %c0_i32 = arith.constant 0 : i32
-        //CHECK: %[[R0:.*]] = gpu.block_id  x
-        //CHECK: %[[R1:.*]] = gpu.block_id  y
-        //CHECK: %[[R2:.*]] = gpu.global_id  x
-        //CHECK: %[[R3:.*]] = gpu.global_id  y
-        //CHECK: %[[R4:.*]] = arith.remui %[[R2]], %[[c8]] : index
-        //CHECK: %[[R5:.*]] = arith.remui %[[R3]], %[[c4]] : index
-        //CHECK: %[[R6:.*]] = arith.muli %[[R2:.*]], %[[c32]] : index
-        //CHECK: %[[R7:.*]] = arith.muli %[[R3:.*]], %[[c64]] : index
-        //CHECK: %[[R8:.*]] = arith.muli %[[R0:.*]], %[[c256]] : index
-        //CHECK: %[[R9:.*]] = arith.muli %[[R1:.*]], %[[c256]] : index
-        //CHECK: %[[R10:.*]] = arith.muli %[[R4]], %[[c4]] : index
-        //CHECK: %[[R11:.*]] = arith.addi %[[R10]], %[[R5]] : index
-        //CHECK: %[[R12:.*]] = arith.muli %[[R11]], %[[c8]] : index
-        //CHECK: %[[R13:.*]] = arith.addi %[[R12]], %[[R8]] : index
-        %wg_id_x = gpu.block_id x
-        %wg_id_y = gpu.block_id y
-        %global_sg_id_x = gpu.global_id x
-        %global_sg_id_y = gpu.global_id y
-        %local_sg_id_x = arith.remui %global_sg_id_x, %c8 : index
-        %local_sg_id_y = arith.remui %global_sg_id_y, %c4 : index
-        %C_sg_tile_offset_x = arith.muli %global_sg_id_x, %c32 : index
-        %C_sg_tile_offset_y = arith.muli %global_sg_id_y, %c64 : index
-        %wg_tile_offset_x = arith.muli %wg_id_x, %c256 : index
-        %wg_tile_offset_y = arith.muli %wg_id_y, %c256 : index
-        %local_sg_id_temp = arith.muli %local_sg_id_x, %c4 : index
-        %local_sg_id = arith.addi %local_sg_id_temp, %local_sg_id_y : index
-        %A_sg_prefetch_offset_x_temp = arith.muli %local_sg_id, %c8 : index
-        %A_sg_prefetch_offset_x = arith.addi %A_sg_prefetch_offset_x_temp, %wg_tile_offset_x : index
-
-        //CHECK: %[[R14:.*]] = xetile.init_tile %[[arg0]][%[[R13]], %[[c0]]] : memref<4096x4096xf16> -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R14]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R15:.*]] = xetile.update_tile_offset %[[R14]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, index, index -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R15]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R16:.*]] = xetile.update_tile_offset %[[R15]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, index, index -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R16]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R17:.*]] = xetile.update_tile_offset %[[R16]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, index, index -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R18:.*]] = arith.remui %[[R4]], %[[c4]] : index
-        //CHECK: %[[R19:.*]] = arith.muli %[[R18]], %[[c8]] : index
-        //CHECK: %[[R20:.*]] = arith.muli %[[R5]], %[[c64]] : index
-        //CHECK: %[[R21:.*]] = arith.divui %[[R4]], %[[c4]] : index
-        //CHECK: %[[R22:.*]] = arith.muli %[[R21]], %[[c32]] : index
-        //CHECK: %[[R23:.*]] = arith.addi %[[R20]], %[[R22]] : index
-        //CHECK: %[[R24:.*]] = arith.addi %[[R9]], %[[R23]] : index
-
-
-        %A_sg_prefetch_tile_iter0 = xetile.init_tile %A[%A_sg_prefetch_offset_x, %c0] : memref<4096x4096xf16> -> !xetile.tile<8x32xf16>
-        xetile.prefetch_tile %A_sg_prefetch_tile_iter0 : !xetile.tile<8x32xf16>
-        %A_sg_prefetch_tile_iter1 = xetile.update_tile_offset %A_sg_prefetch_tile_iter0, [%c0, %c32] : !xetile.tile<8x32xf16>, index, index -> !xetile.tile<8x32xf16>
-        xetile.prefetch_tile %A_sg_prefetch_tile_iter1 : !xetile.tile<8x32xf16>
-        %A_sg_prefetch_tile_iter2 = xetile.update_tile_offset %A_sg_prefetch_tile_iter1, [%c0, %c32] : !xetile.tile<8x32xf16>, index, index -> !xetile.tile<8x32xf16>
-        xetile.prefetch_tile %A_sg_prefetch_tile_iter2 : !xetile.tile<8x32xf16>
-        %A_sg_prefetch_tile_iter3 = xetile.update_tile_offset %A_sg_prefetch_tile_iter2, [%c0, %c32] : !xetile.tile<8x32xf16>, index, index -> !xetile.tile<8x32xf16>
-        %B_sg_prefetch_offset_x_temp0 = arith.remui %local_sg_id_x, %c4 : index
-        %B_sg_prefetch_offset_x = arith.muli %B_sg_prefetch_offset_x_temp0, %c8 : index
-        %B_sg_prefetch_offset_y_temp0 = arith.muli %local_sg_id_y, %c64 : index
-        %B_sg_prefetch_offset_y_temp1 = arith.divui %local_sg_id_x, %c4 : index
-        %B_sg_prefetch_offset_y_temp2 = arith.muli %B_sg_prefetch_offset_y_temp1, %c32 : index
-        %B_sg_prefetch_offset_y_temp3 = arith.addi %B_sg_prefetch_offset_y_temp0, %B_sg_prefetch_offset_y_temp2 : index
-        %B_sg_prefetch_offset_y = arith.addi %wg_tile_offset_y, %B_sg_prefetch_offset_y_temp3 : index
-
-        //CHECK: %[[R25:.*]] = xetile.init_tile %[[arg1]][%[[R19]], %[[R24]]] : memref<4096x4096xf16> -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R25]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R26:.*]] = xetile.update_tile_offset %[[R25]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, index, index -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R26]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R27:.*]] = xetile.update_tile_offset %[[R26]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, index, index -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R27]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R28:.*]] = xetile.update_tile_offset %[[R27]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, index, index -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R29:.*]] = xetile.init_tile %[[arg0]][%[[R6]], %[[c0]]] : memref<4096x4096xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-        //CHECK: %[[R30:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R7]]] : memref<4096x4096xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-        //CHECK: xegpu.alloc_nbarrier 16
-        %B_sg_prefetch_tile_iter0 = xetile.init_tile %B[%B_sg_prefetch_offset_x, %B_sg_prefetch_offset_y]  : memref<4096x4096xf16> -> !xetile.tile<8x32xf16>
-        xetile.prefetch_tile %B_sg_prefetch_tile_iter0 : !xetile.tile<8x32xf16>
-        %B_sg_prefetch_tile_iter1 = xetile.update_tile_offset %B_sg_prefetch_tile_iter0, [%c32, %c0] : !xetile.tile<8x32xf16>, index, index -> !xetile.tile<8x32xf16>
-        xetile.prefetch_tile %B_sg_prefetch_tile_iter1 : !xetile.tile<8x32xf16>
-        %B_sg_prefetch_tile_iter2 = xetile.update_tile_offset %B_sg_prefetch_tile_iter1, [%c32, %c0] : !xetile.tile<8x32xf16>, index, index -> !xetile.tile<8x32xf16>
-        xetile.prefetch_tile %B_sg_prefetch_tile_iter2 : !xetile.tile<8x32xf16>
-        %B_sg_prefetch_tile_iter3 = xetile.update_tile_offset %B_sg_prefetch_tile_iter2, [%c32, %c0] : !xetile.tile<8x32xf16>, index, index -> !xetile.tile<8x32xf16>
-        %A_sg_init_tile = xetile.init_tile %A[%C_sg_tile_offset_x, %c0] : memref<4096x4096xf16> -> !xetile.tile<32x32xf16>
-        %B_sg_init_tile = xetile.init_tile %B[%c0, %C_sg_tile_offset_y] : memref<4096x4096xf16> -> !xetile.tile<32x64xf16>
-        %c_init_val = arith.constant dense<0.0> : vector<32x64xf32>
-        xegpu.alloc_nbarrier 16
-
-        %nbarrier_id = arith.constant 1 : i8
-        %nbarrier_role = arith.constant 0 : i8
-        //CHECK: %[[R31:.*]] = xegpu.init_nbarrier %[[c1_i8]], %[[c0_i8]] : i8, i8 -> !xegpu.nbarrier
-        %nbarrier = xegpu.init_nbarrier %nbarrier_id, %nbarrier_role : i8, i8 -> !xegpu.nbarrier
-        //CHECK: %[[R32:.*]]:5 = scf.for %[[arg4:.*]] = %[[c0]] to %[[c4096]] step %[[c32]] iter_args(%[[arg5:.*]] = %[[R29]], %[[arg6:.*]] = %[[R30]], %[[arg7:.*]] = %[[cst]], %[[arg8:.*]] = %[[R17]], %[[arg9:.*]] = %[[R28]]) -> (!xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x4x8x16xf32>, !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>) {
-        %k_loop_result:5 = scf.for %k = %c0 to %c4096 step %c32 iter_args (
-            %A_tile = %A_sg_init_tile,
-            %B_tile = %B_sg_init_tile,
-            %c_val = %c_init_val,
-
-            %A_prefetch_tile = %A_sg_prefetch_tile_iter3,
-            %B_prefetch_tile = %B_sg_prefetch_tile_iter3
-            ) ->
-            (!xetile.tile<32x32xf16>, !xetile.tile<32x64xf16>,
-            vector<32x64xf32>,
-            !xetile.tile<8x32xf16>, !xetile.tile<8x32xf16>
-            )
-            {
-          //CHECK: %[[R36:.*]] = arith.remui %[[arg4]], %[[c256]] : index
-          //CHECK: %[[R37:.*]] = arith.index_cast %[[R36]] : index to i32
-          //CHECK: %[[R38:.*]] = arith.cmpi eq, %[[R37]], %[[c0_i32]] : i32
-          %every_8th_iter = arith.remui %k, %c256 : index
-          %every_8th_iter_i32 = arith.index_cast %every_8th_iter : index to i32
-          %every_8th_iter_cond = arith.cmpi eq, %every_8th_iter_i32, %c0_i32 : i32
-          //CHECK: scf.if %[[R38]]
-          scf.if %every_8th_iter_cond  {
-            //CHECK: xegpu.nbarrier_arrive %[[R31]] : !xegpu.nbarrier
-            xegpu.nbarrier_arrive %nbarrier : !xegpu.nbarrier
-          }
-          //CHECK: %[[R39:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-          //CHECK: %[[R40:.*]] = xetile.tile_unpack %[[R39]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-          %a_val = xetile.load_tile %A_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-          //CHECK: %[[R41:.*]] = xetile.load_tile %[[arg6]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x4x32x16xf16>
-          //CHECK: %[[R42:.*]] = xetile.tile_unpack %[[R41]] {inner_blocks = array<i64: 32, 16>}  : vector<1x4x32x16xf16> -> vector<32x64xf16>
-          %b_val = xetile.load_tile %B_tile  : !xetile.tile<32x64xf16> -> vector<32x64xf16>
-          //CHECK: xegpu.compile_hint
-          xegpu.compile_hint
-          //CHECK: xetile.prefetch_tile %[[arg8]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-          //CHECK: xetile.prefetch_tile %[[arg9]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-          xetile.prefetch_tile %A_prefetch_tile : !xetile.tile<8x32xf16>
-          xetile.prefetch_tile %B_prefetch_tile : !xetile.tile<8x32xf16>
-          //CHECK: xegpu.compile_hint
-          xegpu.compile_hint
-          //CHECK: %[[R43:.*]] = xetile.update_tile_offset %[[arg8]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, index, index -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-          //CHECK: %[[R44:.*]] = xetile.update_tile_offset %[[arg9]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, index, index -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-          //CHECK: %[[R45:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c0]],  %[[c32]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-          //CHECK: %[[R46:.*]] = xetile.update_tile_offset %[[arg6]], [%[[c32]],  %[[c0]]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-          %next_A_prefetch_tile = xetile.update_tile_offset %A_prefetch_tile, [%c0, %c32] : !xetile.tile<8x32xf16>, index, index -> !xetile.tile<8x32xf16>
-          %next_B_prefetch_tile = xetile.update_tile_offset %B_prefetch_tile, [%c32, %c0] : !xetile.tile<8x32xf16>, index, index -> !xetile.tile<8x32xf16>
-          %next_A_tile = xetile.update_tile_offset %A_tile, [%c0, %c32]  : !xetile.tile<32x32xf16>, index, index -> !xetile.tile<32x32xf16>
-          %next_B_tile = xetile.update_tile_offset %B_tile, [%c32, %c0]  : !xetile.tile<32x64xf16>, index, index -> !xetile.tile<32x64xf16>
-          //CHECK: xegpu.compile_hint
-          xegpu.compile_hint
-          //CHECK: %[[R47:.*]] = xetile.tile_pack %[[R40]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf16> -> vector<4x2x8x16xf16>
-          //CHECK: %[[R48:.*]] = xetile.tile_pack %[[R42]] {inner_blocks = array<i64: 16, 16>}  : vector<32x64xf16> -> vector<2x4x16x16xf16>
-          //CHECK: %[[R51:.*]] = xetile.tile_mma %[[R47]], %[[R48]], %[[arg7]] : vector<4x2x8x16xf16>, vector<2x4x16x16xf16>, vector<4x4x8x16xf32> -> vector<4x4x8x16xf32>
-          %new_c_val = xetile.tile_mma %a_val, %b_val, %c_val : vector<32x32xf16>, vector<32x64xf16>, vector<32x64xf32> -> vector<32x64xf32>
-          //CHECK: xegpu.compile_hint
-          xegpu.compile_hint
-          //CHECK: scf.if %[[R38]]
-          scf.if %every_8th_iter_cond {
-            //CHECK: xegpu.nbarrier_wait %[[R31]] : !xegpu.nbarrier
-            xegpu.nbarrier_wait %nbarrier : !xegpu.nbarrier
-          }
-
-          //CHECK: scf.yield %[[R45]], %[[R46]], %[[R51]], %[[R43]], %[[R44]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x4x8x16xf32>, !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-          scf.yield %next_A_tile, %next_B_tile, %new_c_val,
-                    %next_A_prefetch_tile, %next_B_prefetch_tile
-                    : !xetile.tile<32x32xf16>, !xetile.tile<32x64xf16>, vector<32x64xf32>,
-                    !xetile.tile<8x32xf16>, !xetile.tile<8x32xf16>
-        }
-        //CHECK: %[[R34:.*]] = xetile.init_tile %[[arg2]][%[[R6]], %[[R7]]] : memref<4096x4096xf32> -> !xetile.tile<32x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-        %c_sg_tile = xetile.init_tile %C[%C_sg_tile_offset_x, %C_sg_tile_offset_y] : memref<4096x4096xf32> -> !xetile.tile<32x64xf32>
-        //CHECK: xetile.store_tile %[[R32]]#2,  %[[R34]] : vector<4x4x8x16xf32>, !xetile.tile<32x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-        xetile.store_tile %k_loop_result#2 , %c_sg_tile : vector<32x64xf32>, !xetile.tile<32x64xf32>
-      }
-      //CHECK: gpu.return
-      gpu.return
-    }
-  }
-}
diff --git a/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_f16_f32.mlir b/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_f16_f32.mlir
deleted file mode 100644
index fcf7e188c..000000000
--- a/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_f16_f32.mlir
+++ /dev/null
@@ -1,104 +0,0 @@
-// RUN: imex-opt --xetile-init-duplicate --xetile-blocking --canonicalize --cse %s | FileCheck %s
-
-// CHECK-LABEL: gpu.module @test_kernel {
-gpu.module @test_kernel {
-  // CHECK: gpu.func @test_gemm(%[[A:.*]]: memref<1024x1024xf16>, %[[B:.*]]: memref<1024x1024xf16>, %[[C:.*]]: memref<1024x1024xf32>)
-  gpu.func @test_gemm(%A: memref<1024x1024xf16>, %B: memref<1024x1024xf16>, %C: memref<1024x1024xf32>) {
-
-    //CHECK: %[[C0:.*]] = arith.constant 0 : index
-    %c0 = arith.constant 0 : index
-
-    //CHECK: %[[C1:.*]] = arith.constant 64 : index
-    %c64 = arith.constant 64 : index
-
-    //CHECK: %[[C2:.*]] = arith.constant 1024 : index
-    %c1024 = arith.constant 1024 : index
-
-    //CHECK: %[[R0:.*]] = gpu.block_id  x
-    %block_id_x = gpu.block_id x
-
-    //CHECK: %[[R1:.*]] = gpu.block_id  y
-    %block_id_y = gpu.block_id y
-
-    //CHECK: %[[R2:.*]] = arith.muli %[[R0]], %[[C1]] : index
-    %m = arith.muli %block_id_x, %c64 : index
-
-    //CHECK: %[[R3:.*]] = arith.muli %[[R1]], %[[C1]] : index
-    %n = arith.muli %block_id_y, %c64 : index
-
-    //CHECK: %[[R4:.*]] = xetile.init_tile %[[C]][%[[R2]], %[[R3]]]
-    //CHECK-SAME: memref<1024x1024xf32> -> !xetile.tile<64x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[R5:.*]] = xetile.init_tile %[[C]][%[[R2]], %[[R3]]]
-    //CHECK-SAME: memref<1024x1024xf32> -> !xetile.tile<64x64xf32, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    %c_init_tile = xetile.init_tile %C[%m, %n] : memref<1024x1024xf32> -> !xetile.tile<64x64xf32>
-
-    //CHECK: %[[R6:.*]] = xetile.load_tile %[[R5]]
-    //CHECK-SAME: !xetile.tile<64x64xf32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xf32>
-    %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<64x64xf32> -> vector<64x64xf32>
-
-    //CHECK: %[[R7:.*]] = xetile.init_tile %[[A]][%[[R2]], %[[C0]]]
-    //CHECK-SAME: memref<1024x1024xf16> -> !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<1024x1024xf16> -> !xetile.tile<64x64xf16>
-
-    //CHECK: %[[R8:.*]] = xetile.init_tile %[[B]][%[[C0]], %[[R3]]]
-    //CHECK-SAME: memref<1024x1024xf16> -> !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<1024x1024xf16> -> !xetile.tile<64x64xf16>
-
-    // compute the value of C tile by iterating over tiles in k-dimension and doing dpas
-    //CHECK: %[[R9:.*]]:3 = scf.for %[[arg3:.*]] = %[[C0]] to %[[C2]] step %[[C1]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[R7]], %[[arg5:.*]] = %[[R8]], %[[arg6:.*]] = %[[R6]])
-    //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<2x4x32x16xf32>
-    %out:3 = scf.for %k = %c0 to %c1024 step %c64
-      iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
-      -> (!xetile.tile<64x64xf16>, !xetile.tile<64x64xf16>, vector<64x64xf32>) {
-
-      //CHECK: %[[R10:.*]] = xetile.tile_unpack %[[arg6]] {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xf32> -> vector<64x64xf32>
-
-      //CHECK: %[[R12:.*]] = xetile.load_tile %[[arg4]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xf16>
-      //CHECK: %[[R13:.*]] = xetile.tile_unpack %[[R12]] {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xf16> -> vector<64x64xf16>
-      %a_value = xetile.load_tile %a_tile : !xetile.tile<64x64xf16> -> vector<64x64xf16>
-
-      //CHECK: %[[R14:.*]] = xetile.load_tile %[[arg5]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xf16>
-      //CHECK: %[[R15:.*]] = xetile.tile_unpack %[[R14]] {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xf16> -> vector<64x64xf16>
-      %b_value = xetile.load_tile %b_tile : !xetile.tile<64x64xf16> -> vector<64x64xf16>
-
-      // perform dpas and accumulate
-      //CHECK: %[[R16:.*]] = xetile.tile_pack %[[R13]] {inner_blocks = array<i64: 8, 16>}  : vector<64x64xf16> -> vector<8x4x8x16xf16>
-      //CHECK: %[[R17:.*]] = xetile.tile_pack %[[R15]] {inner_blocks = array<i64: 16, 16>}  : vector<64x64xf16> -> vector<4x4x16x16xf16>
-      //CHECK: %[[R19:.*]] = xetile.tile_pack %[[R10]] {inner_blocks = array<i64: 8, 16>}  : vector<64x64xf32> -> vector<8x4x8x16xf32>
-      //CHECK: %[[R20:.*]] = xetile.tile_mma %[[R16]], %[[R17]], %[[R19]] : vector<8x4x8x16xf16>, vector<4x4x16x16xf16>, vector<8x4x8x16xf32> -> vector<8x4x8x16xf32>
-      //CHECK: %[[R21:.*]] = xetile.tile_unpack %[[R20]] {inner_blocks = array<i64: 8, 16>}  : vector<8x4x8x16xf32> -> vector<64x64xf32>
-      %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value : vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf32> -> vector<64x64xf32>
-
-      // update the offsets for A and B tiles
-      //CHECK: %[[R22:.*]] = xetile.update_tile_offset %[[arg4]], [%[[C0]],  %[[C1]]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c64] : !xetile.tile<64x64xf16>, index, index -> !xetile.tile<64x64xf16>
-
-      //CHECK: %[[R23:.*]] = xetile.update_tile_offset %[[arg5]], [%[[C1]],  %[[C0]]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %b_next_tile = xetile.update_tile_offset %b_tile, [%c64, %c0] : !xetile.tile<64x64xf16>, index, index -> !xetile.tile<64x64xf16>
-
-      //CHECK: %[[R24:.*]] = xetile.tile_pack %[[R21]] {inner_blocks = array<i64: 32, 16>}  : vector<64x64xf32> -> vector<2x4x32x16xf32>
-      //CHECK: scf.yield %[[R22]], %[[R23]], %[[R24]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<2x4x32x16xf32>
-      scf.yield %a_next_tile, %b_next_tile, %c_new_value
-        : !xetile.tile<64x64xf16>, !xetile.tile<64x64xf16>, vector<64x64xf32>
-    }
-    //CHECK: %[[REG12:.*]] = xetile.tile_unpack %[[R9]]#2 {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xf32> -> vector<64x64xf32>
-
-    // store the final accumulated C tile result back to memory
-    //CHECK: %[[REG13:.*]] = xetile.tile_pack %[[REG12]] {inner_blocks = array<i64: 8, 16>}  : vector<64x64xf32> -> vector<8x4x8x16xf32>
-    //CHECK: xetile.store_tile %[[REG13]],  %[[R4]] : vector<8x4x8x16xf32>, !xetile.tile<64x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    xetile.store_tile %out#2, %c_init_tile: vector<64x64xf32>, !xetile.tile<64x64xf32>
-
-    //CHECK: gpu.return
-    gpu.return
-  }
-}
diff --git a/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_f16_f32_slm.mlir b/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
deleted file mode 100644
index 91ae5b63c..000000000
--- a/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
+++ /dev/null
@@ -1,45 +0,0 @@
-// RUN: imex-opt --xetile-init-duplicate --xetile-blocking --canonicalize --cse %s | FileCheck %s
-
-#slm = #xetile.tile_attr<memory_space = 3>
-
-// CHECK-LABEL: gpu.module @test_kernel {
-gpu.module @test_kernel {
-  //CHECK: gpu.func @test_gemm(%[[arg0:.*]]: memref<128x128xf16, 3>, %[[arg1:.*]]: memref<128x128xf16, 3>, %[[arg2:.*]]: memref<128x128xf32>) {
-  gpu.func @test_gemm(%arg0: memref<128x128xf16, 3>, %arg1: memref<128x128xf16, 3>, %arg2: memref<128x128xf32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    %c0 = arith.constant 0 : index
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    %c16 = arith.constant 16 : index
-    %c128 = arith.constant 128 : index
-
-    //CHECK: %[[block_id_x:.*]] = gpu.block_id  x
-    //CHECK: %[[block_id_y:.*]] = gpu.block_id  y
-    //CHECK: %[[r0:.*]] = arith.muli %block_id_x, %[[c16]] : index
-    //CHECK: %[[r1:.*]] = arith.muli %block_id_y, %[[c16]] : index
-    %block_id_x = gpu.block_id  x
-    %block_id_y = gpu.block_id  y
-    %0 = arith.muli %block_id_x, %c16 : index
-    %1 = arith.muli %block_id_y, %c16 : index
-
-    //CHECK: %[[r2:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<128x128xf32> -> !xetile.tile<8x16xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r2]] {padding = 0.000000e+00 : f32}  : !xetile.tile<8x16xf32, #xetile.tile_attr<inner_blocks = [8, 16]>> -> vector<1x1x8x16xf32>
-    %2 = xetile.init_tile %arg2[%0, %1] : memref<128x128xf32> -> !xetile.tile<8x16xf32>
-    %3 = xetile.load_tile %2 {padding = 0.000000e+00 : f32}  : !xetile.tile<8x16xf32> -> vector<8x16xf32>
-
-    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg0]][%[[r0]], %[[c0]]] : memref<128x128xf16, 3> -> !xetile.tile<8x16xf16, #xetile.tile_attr<inner_blocks = [1, 16], memory_space = 3 : i64>>
-    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[r1]]] : memref<128x128xf16, 3> -> !xetile.tile<16x16xf16, #xetile.tile_attr<inner_blocks = [16, 16], memory_space = 3 : i64>>
-    %4 = xetile.init_tile %arg0[%0, %c0] : memref<128x128xf16, 3> -> !xetile.tile<8x16xf16, #slm>
-    %5 = xetile.init_tile %arg1[%c0, %1] : memref<128x128xf16, 3> -> !xetile.tile<16x16xf16, #slm>
-    %6:3 = scf.for %arg3 = %c0 to %c128 step %c16 iter_args(%arg4 = %4, %arg5 = %5, %arg6 = %3)
-          -> (!xetile.tile<8x16xf16, #slm>, !xetile.tile<16x16xf16, #slm>, vector<8x16xf32>) {
-      %7 = xetile.load_tile %arg4 {padding = 0.000000e+00 : f32}  : !xetile.tile<8x16xf16, #slm> -> vector<8x16xf16>
-      %8 = xetile.load_tile %arg5 {padding = 0.000000e+00 : f32}  : !xetile.tile<16x16xf16, #slm> -> vector<16x16xf16>
-      %9 = xetile.tile_mma %7, %8, %arg6 : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      %10 = xetile.update_tile_offset %arg4, [%c0,  %c16] : !xetile.tile<8x16xf16, #slm>, index, index -> !xetile.tile<8x16xf16, #slm>
-      %11 = xetile.update_tile_offset %arg5, [%c16,  %c0] : !xetile.tile<16x16xf16, #slm>, index, index -> !xetile.tile<16x16xf16, #slm>
-      scf.yield %10, %11, %9 : !xetile.tile<8x16xf16, #slm>, !xetile.tile<16x16xf16, #slm>, vector<8x16xf32>
-    }
-    xetile.store_tile %6#2,  %2 : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    gpu.return
-  }
-}
diff --git a/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_i8_i32.mlir b/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_i8_i32.mlir
deleted file mode 100644
index dbad4c66b..000000000
--- a/test/Dialect/XeTile/Transforms/sg_gemm_1k_1k_1k_i8_i32.mlir
+++ /dev/null
@@ -1,85 +0,0 @@
-// RUN: imex-opt --xetile-init-duplicate --xetile-blocking --canonicalize --cse %s | FileCheck %s
-
-// CHECK-LABEL: gpu.module @test_kernel {
-gpu.module @test_kernel {
-
-  //CHECK: gpu.func @test_gemm(%[[arg0:.*]]: memref<1024x1024xi8>, %[[arg1:.*]]: memref<1024x1024xi8>, %[[arg2:.*]]: memref<1024x1024xi32>)
-  gpu.func @test_gemm(%A: memref<1024x1024xi8>, %B: memref<1024x1024xi8>, %C: memref<1024x1024xi32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c64:.*]] = arith.constant 64 : index
-    //CHECK: %[[c1024:.*]] = arith.constant 1024 : index
-    //CHECK: %[[R0:.*]] = gpu.block_id  x
-    //CHECK: %[[R1:.*]] = gpu.block_id  y
-    //CHECK: %[[R2:.*]] = arith.muli %[[R0]], %[[c64]] : index
-    //CHECK: %[[R3:.*]] = arith.muli %[[R1]], %[[c64]] : index
-    %c0 = arith.constant 0 : index
-    %c64 = arith.constant 64 : index
-    %c1024 = arith.constant 1024 : index
-    %block_id_x = gpu.block_id x
-    %block_id_y = gpu.block_id y
-    %m = arith.muli %block_id_x, %c64 : index
-    %n = arith.muli %block_id_y, %c64 : index
-
-    //CHECK: %[[R4:.*]] = xetile.init_tile %[[arg2]][%[[R2]], %[[R3]]]
-    //CHECK-SAME: memref<1024x1024xi32> -> !xetile.tile<64x64xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[R5:.*]] = xetile.init_tile %[[arg2]][%[[R2]], %[[R3]]]
-    //CHECK-SAME: memref<1024x1024xi32> -> !xetile.tile<64x64xi32, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    %c_init_tile = xetile.init_tile %C[%m, %n] : memref<1024x1024xi32> -> !xetile.tile<64x64xi32>
-
-    //CHECK: %[[R6:.*]] = xetile.load_tile %[[R5]]
-    //CHECK-SAME: !xetile.tile<64x64xi32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xi32>
-    %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<64x64xi32> -> vector<64x64xi32>
-
-    //CHECK: %[[R8:.*]] = xetile.init_tile %[[arg0]][%[[R2]], %[[c0]]]
-    //CHECK-SAME: memref<1024x1024xi8> -> !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-    %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<1024x1024xi8> -> !xetile.tile<64x64xi8>
-
-    //CHECK: %[[R9:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R3]]]
-    //CHECK-SAME: memref<1024x1024xi8> -> !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<1024x1024xi8> -> !xetile.tile<64x64xi8>
-
-    //CHECK: %[[R11:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c1024]] step %[[c64]] iter_args(%[[arg4:.*]] = %[[R8]], %[[arg5:.*]] = %[[R9]], %[[arg6:.*]] = %[[R6]])
-    //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>, !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<2x4x32x16xi32>
-    %out:3 = scf.for %k = %c0 to %c1024 step %c64 iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
-                  -> (!xetile.tile<64x64xi8>, !xetile.tile<64x64xi8>, vector<64x64xi32>) {
-      //CHECK: %[[R12:.*]] = xetile.tile_unpack %[[arg6]] {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xi32> -> vector<64x64xi32>
-
-      //CHECK: %[[R14:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<2x2x32x32xi8>
-      //CHECK: %[[R15:.*]] = xetile.tile_unpack %[[R14]] {inner_blocks = array<i64: 32, 32>}  : vector<2x2x32x32xi8> -> vector<64x64xi8>
-      %a_value = xetile.load_tile %a_tile : !xetile.tile<64x64xi8> -> vector<64x64xi8>
-
-      //CHECK: %[[R16:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xi8>
-      %b_value = xetile.load_tile %b_tile : !xetile.tile<64x64xi8> -> vector<64x64xi8>
-
-      //CHECK: %[[R17:.*]] = xetile.tile_pack %[[R15]] {inner_blocks = array<i64: 8, 32>}  : vector<64x64xi8> -> vector<8x2x8x32xi8>
-      //CHECK: %[[R19:.*]] = xetile.tile_pack %[[R12]] {inner_blocks = array<i64: 8, 16>}  : vector<64x64xi32> -> vector<8x4x8x16xi32>
-      //CHECK: %[[R20:.*]] = xetile.tile_mma %[[R17]], %[[R16]], %[[R19]] : vector<8x2x8x32xi8>, vector<2x4x32x16xi8>, vector<8x4x8x16xi32> -> vector<8x4x8x16xi32>
-      //CHECK: %[[R21:.*]] = xetile.tile_unpack %[[R20]] {inner_blocks = array<i64: 8, 16>}  : vector<8x4x8x16xi32> -> vector<64x64xi32>
-      %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value : vector<64x64xi8>, vector<64x64xi8>, vector<64x64xi32> -> vector<64x64xi32>
-
-      //CHECK: %[[R22:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c64]]]
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>, index, index
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c64] : !xetile.tile<64x64xi8>, index, index -> !xetile.tile<64x64xi8>
-
-      //CHECK: %[[R23:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c64]],  %[[c0]]]
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %b_next_tile = xetile.update_tile_offset %b_tile, [%c64, %c0] : !xetile.tile<64x64xi8>, index, index -> !xetile.tile<64x64xi8>
-
-      //CHECK: %[[R24:.*]] = xetile.tile_pack %[[R21]] {inner_blocks = array<i64: 32, 16>}  : vector<64x64xi32> -> vector<2x4x32x16xi32>
-      //CHECK: scf.yield %[[R22]], %[[R23]], %[[R24]]
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<2x4x32x16xi32>
-      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<64x64xi8>, !xetile.tile<64x64xi8>, vector<64x64xi32>
-    }
-    //CHECK: %[[R12:.*]] = xetile.tile_unpack %[[R11]]#2 {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xi32> -> vector<64x64xi32>
-
-    //CHECK: %[[R13:.*]] = xetile.tile_pack %[[R12]] {inner_blocks = array<i64: 8, 16>}  : vector<64x64xi32> -> vector<8x4x8x16xi32>
-    //CHECK: xetile.store_tile %[[R13]],  %[[R4]] : vector<8x4x8x16xi32>, !xetile.tile<64x64xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    xetile.store_tile %out#2, %c_init_tile {innner_blocks = [8, 16]}: vector<64x64xi32>, !xetile.tile<64x64xi32>
-
-    //CHECK: gpu.return
-    gpu.return
-  }
-}
diff --git a/test/Dialect/XeTile/Transforms/sg_gemm_4k_4k_4k_i8_i32.mlir b/test/Dialect/XeTile/Transforms/sg_gemm_4k_4k_4k_i8_i32.mlir
deleted file mode 100644
index d405ad9fb..000000000
--- a/test/Dialect/XeTile/Transforms/sg_gemm_4k_4k_4k_i8_i32.mlir
+++ /dev/null
@@ -1,85 +0,0 @@
-// RUN: imex-opt -xetile-init-duplicate --xetile-blocking --canonicalize --cse %s | FileCheck %s
-
-gpu.module @test_kernel {
-
-  //CHECK: gpu.func @test_gemm(%[[arg0:.*]]: memref<4096x4096xi8>, %[[arg1:.*]]: memref<4096x4096xi8>, %[[arg2:.*]]: memref<4096x4096xi32>) {
-  gpu.func @test_gemm(%A: memref<4096x4096xi8>, %B: memref<4096x4096xi8>, %C: memref<4096x4096xi32>) {
-
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    //CHECK: %[[c256:.*]] = arith.constant 256 : index
-    //CHECK: %[[c4096:.*]] = arith.constant 4096 : index
-    //CHECK: %[[R0:.*]] = gpu.block_id  x
-    //CHECK: %[[R1:.*]] = gpu.block_id  y
-    //CHECK: %[[R2:.*]] = arith.muli %[[R0]], %[[c128]] : index
-    //CHECK: %[[R3:.*]] = arith.muli %[[R1]], %[[c256]] : index
-    %c0 = arith.constant 0 : index
-    %c1 = arith.constant 1 : index
-    %c128 = arith.constant 128 : index
-    %c256 = arith.constant 256 : index
-    %c4096 = arith.constant 4096 : index
-    %block_id_x = gpu.block_id x
-    %block_id_y = gpu.block_id y
-    %m = arith.muli %block_id_x, %c128 : index
-    %n = arith.muli %block_id_y, %c256 : index
-
-    //CHECK: %[[R4:.*]] = xetile.init_tile %[[arg2]][%[[R2]], %[[R3]]] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[R5:.*]] = xetile.init_tile %[[arg2]][%[[R2]], %[[R3]]] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    %c_init_tile = xetile.init_tile %C[%m, %n] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32>
-
-    //CHECK: %[[R6:.*]] = xetile.load_tile %[[R5]] : !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<4x16x32x16xi32>
-    %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<128x256xi32> -> vector<128x256xi32>
-
-    //CHECK: %[[R8:.*]] = xetile.init_tile %[[arg0]][%[[R2]], %[[c0]]] : memref<4096x4096xi8> -> !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-    //CHECK: %[[R9:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R3]]] : memref<4096x4096xi8> -> !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<4096x4096xi8> -> !xetile.tile<128x256xi8>
-    %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<4096x4096xi8> -> !xetile.tile<256x256xi8>
-
-    //CHECK: %[[R11:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c4096]] step %[[c256]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[R8]], %[[arg5:.*]] = %[[R9]], %[[arg6:.*]] = %[[R6]])
-    //CHECK-SAME: !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-    //CHECK-SAME: !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x16x32x16xi32>
-    %out:3 = scf.for %k = %c0 to %c4096 step %c256 iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
-                                                          -> (!xetile.tile<128x256xi8>, !xetile.tile<256x256xi8>, vector<128x256xi32>) {
-      //CHECK: %[[R12:.*]] = xetile.tile_unpack %[[arg6]] {inner_blocks = array<i64: 32, 16>}  : vector<4x16x32x16xi32> -> vector<128x256xi32>
-      //CHECK: %[[R14:.*]] = xetile.load_tile %[[arg4]]
-      //CHECK-SAME: !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<4x8x32x32xi8>
-      //CHECK: %[[R15:.*]] = xetile.tile_unpack %[[R14]] {inner_blocks = array<i64: 32, 32>}  : vector<4x8x32x32xi8> -> vector<128x256xi8>
-      %a_value = xetile.load_tile %a_tile : !xetile.tile<128x256xi8> -> vector<128x256xi8>
-
-      //CHECK: %[[R16:.*]] = xetile.load_tile %[[arg5]]
-      //CHECK-SAME: !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<8x16x32x16xi8>
-      %b_value = xetile.load_tile %b_tile : !xetile.tile<256x256xi8> -> vector<256x256xi8>
-
-      //CHECK: %[[R17:.*]] = xetile.tile_pack %[[R15]] {inner_blocks = array<i64: 8, 32>}  : vector<128x256xi8> -> vector<16x8x8x32xi8>
-      //CHECK: %[[R19:.*]] = xetile.tile_pack %[[R12]] {inner_blocks = array<i64: 8, 16>}  : vector<128x256xi32> -> vector<16x16x8x16xi32>
-      //CHECK: %[[R20:.*]] = xetile.tile_mma %[[R17]], %[[R16]], %[[R19]] : vector<16x8x8x32xi8>, vector<8x16x32x16xi8>, vector<16x16x8x16xi32> -> vector<16x16x8x16xi32>
-      //CHECK: %[[R21:.*]] = xetile.tile_unpack %[[R20]] {inner_blocks = array<i64: 8, 16>}  : vector<16x16x8x16xi32> -> vector<128x256xi32>
-      %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value
-        : vector<128x256xi8>, vector<256x256xi8>, vector<128x256xi32> -> vector<128x256xi32>
-
-      //CHECK: %[[R22:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c256]]]
-      //CHECK-SAME: !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>, index, index
-      //CHECK-SAME: !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      //CHECK: %[[R23:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c256]],  %[[c0]]]
-      //CHECK-SAME: !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, index, index
-      //CHECK-SAME: !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c256]
-        : !xetile.tile<128x256xi8>, index, index -> !xetile.tile<128x256xi8>
-      %b_next_tile = xetile.update_tile_offset %b_tile, [%c256, %c0]
-        : !xetile.tile<256x256xi8>, index, index -> !xetile.tile<256x256xi8>
-
-      //CHECK: %[[R24:.*]] = xetile.tile_pack %[[R21]] {inner_blocks = array<i64: 32, 16>}  : vector<128x256xi32> -> vector<4x16x32x16xi32>
-      //CHECK: scf.yield %[[R22]], %[[R23]], %[[R24]]
-      //CHECK-SAME: !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      //CHECK-SAME: !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x16x32x16xi32>
-      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<128x256xi8>, !xetile.tile<256x256xi8>, vector<128x256xi32>
-    }
-    //CHECK: %[[R12:.*]] = xetile.tile_unpack %[[R11]]#2 {inner_blocks = array<i64: 32, 16>}  : vector<4x16x32x16xi32> -> vector<128x256xi32>
-    //CHECK: %[[R13:.*]] = xetile.tile_pack %[[R12]] {inner_blocks = array<i64: 8, 16>}  : vector<128x256xi32> -> vector<16x16x8x16xi32>
-    //CHECK: xetile.store_tile %[[R13]],  %[[R4]] : vector<16x16x8x16xi32>, !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    xetile.store_tile %out#2, %c_init_tile : vector<128x256xi32>, !xetile.tile<128x256xi32>
-    //CHECK: gpu.return
-    gpu.return
-  }
-}
diff --git a/test/Integration/Dialect/XeTile/xetile-to-func-vc-optimize-transpose.pp b/test/Integration/Dialect/XeTile/xetile-to-func-vc-optimize-transpose.pp
index 5797fde0c..e9eb4be51 100644
--- a/test/Integration/Dialect/XeTile/xetile-to-func-vc-optimize-transpose.pp
+++ b/test/Integration/Dialect/XeTile/xetile-to-func-vc-optimize-transpose.pp
@@ -2,7 +2,7 @@
     cse
     gpu.module(xetile-init-duplicate
         xetile-canonicalization
-        new-xetile-blocking
+        xetile-blocking
         convert-xetile-to-xegpu
         cse
         imex-xegpu-hoist-transpose
diff --git a/test/Integration/Dialect/XeTile/xetile-to-func-vc.pp b/test/Integration/Dialect/XeTile/xetile-to-func-vc.pp
index 60e5785b2..69bad7f29 100644
--- a/test/Integration/Dialect/XeTile/xetile-to-func-vc.pp
+++ b/test/Integration/Dialect/XeTile/xetile-to-func-vc.pp
@@ -3,7 +3,9 @@
     gpu.module(xetile-init-duplicate
         xetile-canonicalization
         xetile-blocking
+	cse
         convert-xetile-to-xegpu
+	cse
         imex-xegpu-apply-vnni-transformation)
     cse
     imex-vector-linearize
diff --git a/test/Integration/Dialect/XeTile/xetile-wg-to-func-vc.pp b/test/Integration/Dialect/XeTile/xetile-wg-to-func-vc.pp
index 94078a267..531ebe55c 100644
--- a/test/Integration/Dialect/XeTile/xetile-wg-to-func-vc.pp
+++ b/test/Integration/Dialect/XeTile/xetile-wg-to-func-vc.pp
@@ -4,10 +4,11 @@
         cse
         xetile-init-duplicate
         xetile-canonicalization
-        new-xetile-blocking
+        xetile-blocking
         canonicalize
         convert-xetile-to-xegpu
-        imex-propagate-packed-layout)
+        cse
+        imex-xegpu-apply-vnni-transformation)
     cse
     imex-vector-linearize
     gpu.module(convert-xegpu-to-vc)
diff --git a/test/Transforms/propagate-packed-layout.mlir b/test/Transforms/propagate-packed-layout.mlir
deleted file mode 100644
index 0c42d61fb..000000000
--- a/test/Transforms/propagate-packed-layout.mlir
+++ /dev/null
@@ -1,339 +0,0 @@
-// RUN: imex-opt %s -split-input-file -imex-propagate-packed-layout | FileCheck %s
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: vector<8x16xf16>, %[[ARG2:.*]]: vector<16x16xf16>)
-//       CHECK:  %[[B1:.*]] = vector.shape_cast %[[ARG2]] : vector<16x16xf16> to vector<256xf16>
-//       CHECK:  %[[B2:.*]] = vector.shuffle %[[B1]], %[[B1]]
-// CHECK: [0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31,
-// CHECK: 32, 48, 33, 49, 34, 50, 35, 51, 36, 52, 37, 53, 38, 54, 39, 55, 40, 56, 41, 57, 42, 58, 43, 59, 44, 60, 45, 61, 46, 62, 47, 63,
-// CHECK: 64, 80, 65, 81, 66, 82, 67, 83, 68, 84, 69, 85, 70, 86, 71, 87, 72, 88, 73, 89, 74, 90, 75, 91, 76, 92, 77, 93, 78, 94, 79, 95,
-// CHECK: 96, 112, 97, 113, 98, 114, 99, 115, 100, 116, 101, 117, 102, 118, 103, 119, 104, 120, 105, 121, 106, 122, 107, 123, 108, 124, 109, 125, 110, 126, 111, 127,
-// CHECK: 128, 144, 129, 145, 130, 146, 131, 147, 132, 148, 133, 149, 134, 150, 135, 151, 136, 152, 137, 153, 138, 154, 139, 155, 140, 156, 141, 157, 142, 158, 143, 159,
-// CHECK: 160, 176, 161, 177, 162, 178, 163, 179, 164, 180, 165, 181, 166, 182, 167, 183, 168, 184, 169, 185, 170, 186, 171, 187, 172, 188, 173, 189, 174, 190, 175, 191,
-// CHECK: 192, 208, 193, 209, 194, 210, 195, 211, 196, 212, 197, 213, 198, 214, 199, 215, 200, 216, 201, 217, 202, 218, 203, 219, 204, 220, 205, 221, 206, 222, 207, 223,
-// CHECK: 224, 240, 225, 241, 226, 242, 227, 243, 228, 244, 229, 245, 230, 246, 231, 247, 232, 248, 233, 249, 234, 250, 235, 251, 236, 252, 237, 253, 238, 254, 239, 255] : vector<256xf16>, vector<256xf16>
-//       CHECK:  %[[B3:.*]] = vector.shape_cast %[[B2]] : vector<256xf16> to vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[ARG1]], %[[B3]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]]
-
-func.func @test(%arg1 : vector<8x16xf16>, %arg2 : vector<16x16xf16>) -> vector<8x16xf32> {
-  %0 = xegpu.dpas %arg1, %arg2 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %0 : vector<8x16xf32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: vector<8x32xi8>, %[[ARG2:.*]]: vector<32x32xi8>) -> vector<8x32xi32> {
-//       CHECK: %[[B1:.*]] = vector.shape_cast %[[ARG2]] : vector<32x32xi8> to vector<1024xi8>
-//       CHECK: %[[B2:.*]] = vector.shuffle %[[B1]], %[[B1]]
-// CHECK: [0, 32, 64, 96, 1, 33, 65, 97, 2, 34, 66, 98, 3, 35, 67, 99, 4, 36, 68, 100, 5, 37, 69, 101, 6, 38, 70, 102, 7, 39, 71, 103, 8, 40, 72, 104, 9, 41, 73, 105, 10, 42, 74, 106, 11, 43, 75, 107, 12, 44, 76, 108, 13, 45, 77, 109, 14, 46, 78, 110, 15, 47, 79, 111, 16, 48, 80, 112, 17, 49, 81, 113, 18, 50, 82, 114, 19, 51, 83, 115, 20, 52, 84, 116, 21, 53, 85, 117, 22, 54, 86, 118, 23, 55, 87, 119, 24, 56, 88, 120, 25, 57, 89, 121, 26, 58, 90, 122, 27, 59, 91, 123, 28, 60, 92, 124, 29, 61, 93, 125, 30, 62, 94, 126, 31, 63, 95, 127,
-// CHECK: 128, 160, 192, 224, 129, 161, 193, 225, 130, 162, 194, 226, 131, 163, 195, 227, 132, 164, 196, 228, 133, 165, 197, 229, 134, 166, 198, 230, 135, 167, 199, 231, 136, 168, 200, 232, 137, 169, 201, 233, 138, 170, 202, 234, 139, 171, 203, 235, 140, 172, 204, 236, 141, 173, 205, 237, 142, 174, 206, 238, 143, 175, 207, 239, 144, 176, 208, 240, 145, 177, 209, 241, 146, 178, 210, 242, 147, 179, 211, 243, 148, 180, 212, 244, 149, 181, 213, 245, 150, 182, 214, 246, 151, 183, 215, 247, 152, 184, 216, 248, 153, 185, 217, 249, 154, 186, 218, 250, 155, 187, 219, 251, 156, 188, 220, 252, 157, 189, 221, 253, 158, 190, 222, 254, 159, 191, 223, 255,
-// CHECK: 256, 288, 320, 352, 257, 289, 321, 353, 258, 290, 322, 354, 259, 291, 323, 355, 260, 292, 324, 356, 261, 293, 325, 357, 262, 294, 326, 358, 263, 295, 327, 359, 264, 296, 328, 360, 265, 297, 329, 361, 266, 298, 330, 362, 267, 299, 331, 363, 268, 300, 332, 364, 269, 301, 333, 365, 270, 302, 334, 366, 271, 303, 335, 367, 272, 304, 336, 368, 273, 305, 337, 369, 274, 306, 338, 370, 275, 307, 339, 371, 276, 308, 340, 372, 277, 309, 341, 373, 278, 310, 342, 374, 279, 311, 343, 375, 280, 312, 344, 376, 281, 313, 345, 377, 282, 314, 346, 378, 283, 315, 347, 379, 284, 316, 348, 380, 285, 317, 349, 381, 286, 318, 350, 382, 287, 319, 351, 383,
-// CHECK: 384, 416, 448, 480, 385, 417, 449, 481, 386, 418, 450, 482, 387, 419, 451, 483, 388, 420, 452, 484, 389, 421, 453, 485, 390, 422, 454, 486, 391, 423, 455, 487, 392, 424, 456, 488, 393, 425, 457, 489, 394, 426, 458, 490, 395, 427, 459, 491, 396, 428, 460, 492, 397, 429, 461, 493, 398, 430, 462, 494, 399, 431, 463, 495, 400, 432, 464, 496, 401, 433, 465, 497, 402, 434, 466, 498, 403, 435, 467, 499, 404, 436, 468, 500, 405, 437, 469, 501, 406, 438, 470, 502, 407, 439, 471, 503, 408, 440, 472, 504, 409, 441, 473, 505, 410, 442, 474, 506, 411, 443, 475, 507, 412, 444, 476, 508, 413, 445, 477, 509, 414, 446, 478, 510, 415, 447, 479, 511,
-// CHECK: 512, 544, 576, 608, 513, 545, 577, 609, 514, 546, 578, 610, 515, 547, 579, 611, 516, 548, 580, 612, 517, 549, 581, 613, 518, 550, 582, 614, 519, 551, 583, 615, 520, 552, 584, 616, 521, 553, 585, 617, 522, 554, 586, 618, 523, 555, 587, 619, 524, 556, 588, 620, 525, 557, 589, 621, 526, 558, 590, 622, 527, 559, 591, 623, 528, 560, 592, 624, 529, 561, 593, 625, 530, 562, 594, 626, 531, 563, 595, 627, 532, 564, 596, 628, 533, 565, 597, 629, 534, 566, 598, 630, 535, 567, 599, 631, 536, 568, 600, 632, 537, 569, 601, 633, 538, 570, 602, 634, 539, 571, 603, 635, 540, 572, 604, 636, 541, 573, 605, 637, 542, 574, 606, 638, 543, 575, 607, 639,
-// CHECK: 640, 672, 704, 736, 641, 673, 705, 737, 642, 674, 706, 738, 643, 675, 707, 739, 644, 676, 708, 740, 645, 677, 709, 741, 646, 678, 710, 742, 647, 679, 711, 743, 648, 680, 712, 744, 649, 681, 713, 745, 650, 682, 714, 746, 651, 683, 715, 747, 652, 684, 716, 748, 653, 685, 717, 749, 654, 686, 718, 750, 655, 687, 719, 751, 656, 688, 720, 752, 657, 689, 721, 753, 658, 690, 722, 754, 659, 691, 723, 755, 660, 692, 724, 756, 661, 693, 725, 757, 662, 694, 726, 758, 663, 695, 727, 759, 664, 696, 728, 760, 665, 697, 729, 761, 666, 698, 730, 762, 667, 699, 731, 763, 668, 700, 732, 764, 669, 701, 733, 765, 670, 702, 734, 766, 671, 703, 735, 767,
-// CHECK: 768, 800, 832, 864, 769, 801, 833, 865, 770, 802, 834, 866, 771, 803, 835, 867, 772, 804, 836, 868, 773, 805, 837, 869, 774, 806, 838, 870, 775, 807, 839, 871, 776, 808, 840, 872, 777, 809, 841, 873, 778, 810, 842, 874, 779, 811, 843, 875, 780, 812, 844, 876, 781, 813, 845, 877, 782, 814, 846, 878, 783, 815, 847, 879, 784, 816, 848, 880, 785, 817, 849, 881, 786, 818, 850, 882, 787, 819, 851, 883, 788, 820, 852, 884, 789, 821, 853, 885, 790, 822, 854, 886, 791, 823, 855, 887, 792, 824, 856, 888, 793, 825, 857, 889, 794, 826, 858, 890, 795, 827, 859, 891, 796, 828, 860, 892, 797, 829, 861, 893, 798, 830, 862, 894, 799, 831, 863, 895,
-// CHECK: 896, 928, 960, 992, 897, 929, 961, 993, 898, 930, 962, 994, 899, 931, 963, 995, 900, 932, 964, 996, 901, 933, 965, 997, 902, 934, 966, 998, 903, 935, 967, 999, 904, 936, 968, 1000, 905, 937, 969, 1001, 906, 938, 970, 1002, 907, 939, 971, 1003, 908, 940, 972, 1004, 909, 941, 973, 1005, 910, 942, 974, 1006, 911, 943, 975, 1007, 912, 944, 976, 1008, 913, 945, 977, 1009, 914, 946, 978, 1010, 915, 947, 979, 1011, 916, 948, 980, 1012, 917, 949, 981, 1013, 918, 950, 982, 1014, 919, 951, 983, 1015, 920, 952, 984, 1016, 921, 953, 985, 1017, 922, 954, 986, 1018, 923, 955, 987, 1019, 924, 956, 988, 1020, 925, 957, 989, 1021, 926, 958, 990, 1022, 927, 959, 991, 1023] : vector<1024xi8>, vector<1024xi8>
-//       CHECK: %[[B3:.*]] = vector.shape_cast %[[B2]] : vector<1024xi8> to vector<8x32x4xi8>
-//       CHECK: %[[RES:.*]] = xegpu.dpas %[[ARG1]], %[[B3]] : vector<8x32xi8>, vector<8x32x4xi8> -> vector<8x32xi32>
-//       CHECK: return %[[RES]] : vector<8x32xi32>
-
-func.func @test(%arg1 : vector<8x32xi8>, %arg2 : vector<32x32xi8>) -> vector<8x32xi32> {
-  %0 = xegpu.dpas %arg1, %arg2 : vector<8x32xi8>, vector<32x32xi8> -> vector<8x32xi32>
-  return %0 : vector<8x32xi32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]] : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>) -> vector<8x16xf32> {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %2 = xegpu.dpas %0, %1 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %2 : vector<8x16xf32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  %[[RES1:.*]] = xegpu.dpas %[[A]], %[[B]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  %[[RES2:.*]] = xegpu.dpas %[[A]], %[[B]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES1]], %[[RES2]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>) -> (vector<8x16xf32>, vector<8x16xf32>) {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %2 = xegpu.dpas %0, %1 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  %3 = xegpu.dpas %0, %1 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %2, %3 : vector<8x16xf32>, vector<8x16xf32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B:.*]] = xegpu.load_nd %[[ARG2]] : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-//       CHECK:  %[[B1:.*]] = vector.shape_cast %[[B]] : vector<16x16xf16> to vector<256xf16>
-//       CHECK:  %[[B2:.*]] = vector.shuffle %[[B1]], %[[B1]]
-// CHECK: [0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31,
-// CHECK: 32, 48, 33, 49, 34, 50, 35, 51, 36, 52, 37, 53, 38, 54, 39, 55, 40, 56, 41, 57, 42, 58, 43, 59, 44, 60, 45, 61, 46, 62, 47, 63,
-// CHECK: 64, 80, 65, 81, 66, 82, 67, 83, 68, 84, 69, 85, 70, 86, 71, 87, 72, 88, 73, 89, 74, 90, 75, 91, 76, 92, 77, 93, 78, 94, 79, 95,
-// CHECK: 96, 112, 97, 113, 98, 114, 99, 115, 100, 116, 101, 117, 102, 118, 103, 119, 104, 120, 105, 121, 106, 122, 107, 123, 108, 124, 109, 125, 110, 126, 111, 127,
-// CHECK: 128, 144, 129, 145, 130, 146, 131, 147, 132, 148, 133, 149, 134, 150, 135, 151, 136, 152, 137, 153, 138, 154, 139, 155, 140, 156, 141, 157, 142, 158, 143, 159,
-// CHECK: 160, 176, 161, 177, 162, 178, 163, 179, 164, 180, 165, 181, 166, 182, 167, 183, 168, 184, 169, 185, 170, 186, 171, 187, 172, 188, 173, 189, 174, 190, 175, 191,
-// CHECK: 192, 208, 193, 209, 194, 210, 195, 211, 196, 212, 197, 213, 198, 214, 199, 215, 200, 216, 201, 217, 202, 218, 203, 219, 204, 220, 205, 221, 206, 222, 207, 223,
-// CHECK: 224, 240, 225, 241, 226, 242, 227, 243, 228, 244, 229, 245, 230, 246, 231, 247, 232, 248, 233, 249, 234, 250, 235, 251, 236, 252, 237, 253, 238, 254, 239, 255] : vector<256xf16>, vector<256xf16>
-//       CHECK:  %[[B3:.*]] = vector.shape_cast %[[B2]] : vector<256xf16> to vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B3]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>) -> (vector<8x16xf32>, vector<16x16xf16>) {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %2 = xegpu.dpas %0, %1 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %2, %1 : vector<8x16xf32>, vector<16x16xf16>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  %[[B1:.*]] = arith.extf %[[B]] : vector<8x16x2xf16> to vector<8x16x2xf32>
-//       CHECK:  %[[B2:.*]] = arith.truncf %[[B1]] : vector<8x16x2xf32> to vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B2]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>) -> vector<8x16xf32> {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %2 = arith.extf %1: vector<16x16xf16> to vector<16x16xf32>
-  %3 = arith.truncf %2: vector<16x16xf32> to vector<16x16xf16>
-  %4 = xegpu.dpas %0, %3 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %4 : vector<8x16xf32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B1:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  %[[B2:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  %[[B3:.*]] = arith.addf %[[B1]], %[[B2]] : vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B3]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>) -> vector<8x16xf32> {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %2 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %3 = arith.addf %1, %2 : vector<16x16xf16>
-  %4 = xegpu.dpas %0, %3 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %4 : vector<8x16xf32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B1:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  %[[B2:.*]] = arith.constant dense<1.000000e+00> : vector<16x16xf16>
-//       CHECK:  %[[B3:.*]] = vector.shape_cast %[[B2]] : vector<16x16xf16> to vector<256xf16>
-//       CHECK:  %[[B4:.*]] = vector.shuffle %[[B3]], %[[B3]]
-// CHECK: [0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31,
-// CHECK: 32, 48, 33, 49, 34, 50, 35, 51, 36, 52, 37, 53, 38, 54, 39, 55, 40, 56, 41, 57, 42, 58, 43, 59, 44, 60, 45, 61, 46, 62, 47, 63,
-// CHECK: 64, 80, 65, 81, 66, 82, 67, 83, 68, 84, 69, 85, 70, 86, 71, 87, 72, 88, 73, 89, 74, 90, 75, 91, 76, 92, 77, 93, 78, 94, 79, 95,
-// CHECK: 96, 112, 97, 113, 98, 114, 99, 115, 100, 116, 101, 117, 102, 118, 103, 119, 104, 120, 105, 121, 106, 122, 107, 123, 108, 124, 109, 125, 110, 126, 111, 127,
-// CHECK: 128, 144, 129, 145, 130, 146, 131, 147, 132, 148, 133, 149, 134, 150, 135, 151, 136, 152, 137, 153, 138, 154, 139, 155, 140, 156, 141, 157, 142, 158, 143, 159,
-// CHECK: 160, 176, 161, 177, 162, 178, 163, 179, 164, 180, 165, 181, 166, 182, 167, 183, 168, 184, 169, 185, 170, 186, 171, 187, 172, 188, 173, 189, 174, 190, 175, 191,
-// CHECK: 192, 208, 193, 209, 194, 210, 195, 211, 196, 212, 197, 213, 198, 214, 199, 215, 200, 216, 201, 217, 202, 218, 203, 219, 204, 220, 205, 221, 206, 222, 207, 223,
-// CHECK: 224, 240, 225, 241, 226, 242, 227, 243, 228, 244, 229, 245, 230, 246, 231, 247, 232, 248, 233, 249, 234, 250, 235, 251, 236, 252, 237, 253, 238, 254, 239, 255] : vector<256xf16>, vector<256xf16>
-//       CHECK:  %[[B5:.*]] = vector.shape_cast %[[B4]] : vector<256xf16> to vector<8x16x2xf16>
-//       CHECK:  %[[B6:.*]] = arith.addf %[[B1]], %[[B5]] : vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B6]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>) -> vector<8x16xf32> {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %2 = arith.constant dense<1.0> : vector<16x16xf16>
-  %3 = arith.addf %1, %2 : vector<16x16xf16>
-  %4 = xegpu.dpas %0, %3 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %4 : vector<8x16xf32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B1:.*]] = xegpu.load_nd %[[ARG2]] : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-//       CHECK:  %[[B2:.*]] = xegpu.load_nd %[[ARG2]] : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-//       CHECK:  %[[B3:.*]] = arith.addf %[[B1]], %[[B2]] : vector<16x16xf16>
-//       CHECK:  %[[B4:.*]] = vector.shape_cast %[[B3]] : vector<16x16xf16> to vector<256xf16>
-//       CHECK:  %[[B5:.*]] = vector.shuffle %[[B4]], %[[B4]]
-// CHECK: [0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31,
-// CHECK: 32, 48, 33, 49, 34, 50, 35, 51, 36, 52, 37, 53, 38, 54, 39, 55, 40, 56, 41, 57, 42, 58, 43, 59, 44, 60, 45, 61, 46, 62, 47, 63,
-// CHECK: 64, 80, 65, 81, 66, 82, 67, 83, 68, 84, 69, 85, 70, 86, 71, 87, 72, 88, 73, 89, 74, 90, 75, 91, 76, 92, 77, 93, 78, 94, 79, 95,
-// CHECK: 96, 112, 97, 113, 98, 114, 99, 115, 100, 116, 101, 117, 102, 118, 103, 119, 104, 120, 105, 121, 106, 122, 107, 123, 108, 124, 109, 125, 110, 126, 111, 127,
-// CHECK: 128, 144, 129, 145, 130, 146, 131, 147, 132, 148, 133, 149, 134, 150, 135, 151, 136, 152, 137, 153, 138, 154, 139, 155, 140, 156, 141, 157, 142, 158, 143, 159,
-// CHECK: 160, 176, 161, 177, 162, 178, 163, 179, 164, 180, 165, 181, 166, 182, 167, 183, 168, 184, 169, 185, 170, 186, 171, 187, 172, 188, 173, 189, 174, 190, 175, 191,
-// CHECK: 192, 208, 193, 209, 194, 210, 195, 211, 196, 212, 197, 213, 198, 214, 199, 215, 200, 216, 201, 217, 202, 218, 203, 219, 204, 220, 205, 221, 206, 222, 207, 223,
-// CHECK: 224, 240, 225, 241, 226, 242, 227, 243, 228, 244, 229, 245, 230, 246, 231, 247, 232, 248, 233, 249, 234, 250, 235, 251, 236, 252, 237, 253, 238, 254, 239, 255] : vector<256xf16>, vector<256xf16>
-//       CHECK:  %[[B6:.*]] = vector.shape_cast %[[B5]] : vector<256xf16> to vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B6]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]], %[[B2]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>) -> (vector<8x16xf32>, vector<16x16xf16>) {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %2 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %3 = arith.addf %1, %2 : vector<16x16xf16>
-  %4 = xegpu.dpas %0, %3 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %4, %2 : vector<8x16xf32>, vector<16x16xf16>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>, %{{.*}}: index)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  %[[RES1:.*]]:2 = scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[ITER1:.*]] = %[[B]], %[[ITER2:.*]] = %[[RES]]) -> (vector<8x16x2xf16>, vector<8x16xf32>) {
-//       CHECK:  %[[B1:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  %[[B2:.*]] = arith.addf %[[ITER1]], %[[B1]] : vector<8x16x2xf16>
-//       CHECK:  %[[RES2:.*]] = xegpu.dpas %[[A]], %[[B2]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  scf.yield %[[B2]], %[[RES2]] : vector<8x16x2xf16>, vector<8x16xf32>
-//       CHECK:  }
-//       CHECK:  return %[[RES1]]#1 : vector<8x16xf32>
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>, %arg3 : index) -> vector<8x16xf32> {
-  %c0 = arith.constant 0 : index
-  %c1 = arith.constant 1 : index
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-  %2 = xegpu.dpas %0, %1 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  %3:2 = scf.for %i = %c0 to %arg3 step %c1 iter_args(%iter = %1, %res = %2) -> (vector<16x16xf16>, vector<8x16xf32>) {
-    %4 = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-    %5 = arith.addf %iter, %4 : vector<16x16xf16>
-    %6 = xegpu.dpas %0, %5 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-    scf.yield %5, %6: vector<16x16xf16>, vector<8x16xf32>
-  }
-  return %3#1 : vector<8x16xf32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>, %{{.*}}: i1)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B:.*]] = scf.if %{{.*}} -> (vector<8x16x2xf16>)
-//       CHECK:  %[[B1:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  scf.yield %[[B1]]
-//       CHECK:  else
-//       CHECK:  %[[B2:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  scf.yield %[[B2]]
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>, %arg3 : i1) -> vector<8x16xf32> {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = scf.if %arg3 -> (vector<16x16xf16>) {
-    %b = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-    scf.yield %b : vector<16x16xf16>
-  } else {
-    %b = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-    scf.yield %b : vector<16x16xf16>
-  }
-  %2 = xegpu.dpas %0, %1 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %2 : vector<8x16xf32>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>, %{{.*}}: i1)
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B:.*]] = scf.if %{{.*}} -> (vector<16x16xf16>)
-//       CHECK:  %[[B1:.*]] = xegpu.load_nd %[[ARG2]] : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-//       CHECK:  scf.yield %[[B1]]
-//       CHECK:  else
-//       CHECK:  %[[B2:.*]] = xegpu.load_nd %[[ARG2]] : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-//       CHECK:  scf.yield %[[B2]]
-//       CHECK:  %[[B3:.*]] = vector.shape_cast %[[B]] : vector<16x16xf16> to vector<256xf16>
-//       CHECK:  %[[B4:.*]] = vector.shuffle %[[B3]], %[[B3]]
-// CHECK: [0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31,
-// CHECK: 32, 48, 33, 49, 34, 50, 35, 51, 36, 52, 37, 53, 38, 54, 39, 55, 40, 56, 41, 57, 42, 58, 43, 59, 44, 60, 45, 61, 46, 62, 47, 63,
-// CHECK: 64, 80, 65, 81, 66, 82, 67, 83, 68, 84, 69, 85, 70, 86, 71, 87, 72, 88, 73, 89, 74, 90, 75, 91, 76, 92, 77, 93, 78, 94, 79, 95,
-// CHECK: 96, 112, 97, 113, 98, 114, 99, 115, 100, 116, 101, 117, 102, 118, 103, 119, 104, 120, 105, 121, 106, 122, 107, 123, 108, 124, 109, 125, 110, 126, 111, 127,
-// CHECK: 128, 144, 129, 145, 130, 146, 131, 147, 132, 148, 133, 149, 134, 150, 135, 151, 136, 152, 137, 153, 138, 154, 139, 155, 140, 156, 141, 157, 142, 158, 143, 159,
-// CHECK: 160, 176, 161, 177, 162, 178, 163, 179, 164, 180, 165, 181, 166, 182, 167, 183, 168, 184, 169, 185, 170, 186, 171, 187, 172, 188, 173, 189, 174, 190, 175, 191,
-// CHECK: 192, 208, 193, 209, 194, 210, 195, 211, 196, 212, 197, 213, 198, 214, 199, 215, 200, 216, 201, 217, 202, 218, 203, 219, 204, 220, 205, 221, 206, 222, 207, 223,
-// CHECK: 224, 240, 225, 241, 226, 242, 227, 243, 228, 244, 229, 245, 230, 246, 231, 247, 232, 248, 233, 249, 234, 250, 235, 251, 236, 252, 237, 253, 238, 254, 239, 255] : vector<256xf16>, vector<256xf16>
-//       CHECK:  %[[B5:.*]] = vector.shape_cast %[[B4]] : vector<256xf16> to vector<8x16x2xf16>
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B5]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]], %[[B]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>, %arg3 : i1) -> (vector<8x16xf32>, vector<16x16xf16>) {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = scf.if %arg3 -> (vector<16x16xf16>) {
-    %b = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-    scf.yield %b : vector<16x16xf16>
-  } else {
-    %b = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-    scf.yield %b : vector<16x16xf16>
-  }
-  %2 = xegpu.dpas %0, %1 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %2, %1 : vector<8x16xf32>, vector<16x16xf16>
-}
-
-// -----
-
-// CHECK-LABEL: @test
-//  CHECK-SAME: (%[[ARG1:.*]]: !xegpu.tensor_desc<8x16xf16>, %[[ARG2:.*]]: !xegpu.tensor_desc<16x16xf16>, %[[ARG3:.*]]: vector<16x16xf16>, %{{.*}}: i1)
-//       CHECK:  %[[B2:.*]] = vector.shape_cast %[[ARG3]] : vector<16x16xf16> to vector<256xf16>
-//       CHECK:  %[[B3:.*]] = vector.shuffle %[[B2]], %[[B2]]
-// CHECK: [0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31,
-// CHECK: 32, 48, 33, 49, 34, 50, 35, 51, 36, 52, 37, 53, 38, 54, 39, 55, 40, 56, 41, 57, 42, 58, 43, 59, 44, 60, 45, 61, 46, 62, 47, 63,
-// CHECK: 64, 80, 65, 81, 66, 82, 67, 83, 68, 84, 69, 85, 70, 86, 71, 87, 72, 88, 73, 89, 74, 90, 75, 91, 76, 92, 77, 93, 78, 94, 79, 95,
-// CHECK: 96, 112, 97, 113, 98, 114, 99, 115, 100, 116, 101, 117, 102, 118, 103, 119, 104, 120, 105, 121, 106, 122, 107, 123, 108, 124, 109, 125, 110, 126, 111, 127,
-// CHECK: 128, 144, 129, 145, 130, 146, 131, 147, 132, 148, 133, 149, 134, 150, 135, 151, 136, 152, 137, 153, 138, 154, 139, 155, 140, 156, 141, 157, 142, 158, 143, 159,
-// CHECK: 160, 176, 161, 177, 162, 178, 163, 179, 164, 180, 165, 181, 166, 182, 167, 183, 168, 184, 169, 185, 170, 186, 171, 187, 172, 188, 173, 189, 174, 190, 175, 191,
-// CHECK: 192, 208, 193, 209, 194, 210, 195, 211, 196, 212, 197, 213, 198, 214, 199, 215, 200, 216, 201, 217, 202, 218, 203, 219, 204, 220, 205, 221, 206, 222, 207, 223,
-// CHECK: 224, 240, 225, 241, 226, 242, 227, 243, 228, 244, 229, 245, 230, 246, 231, 247, 232, 248, 233, 249, 234, 250, 235, 251, 236, 252, 237, 253, 238, 254, 239, 255] : vector<256xf16>, vector<256xf16>
-//       CHECK:  %[[B4:.*]] = vector.shape_cast %[[B3]] : vector<256xf16> to vector<8x16x2xf16>
-//       CHECK:  %[[A:.*]] = xegpu.load_nd %[[ARG1]]  : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-//       CHECK:  %[[B:.*]] = scf.if %{{.*}} -> (vector<8x16x2xf16>)
-//       CHECK:  %[[B1:.*]] = xegpu.load_nd %[[ARG2]] <{packed}> : !xegpu.tensor_desc<16x16xf16> -> vector<8x16x2xf16>
-//       CHECK:  scf.yield %[[B1]]
-//       CHECK:  else
-//       CHECK:  scf.yield %[[B4]]
-//       CHECK:  %[[RES:.*]] = xegpu.dpas %[[A]], %[[B]] : vector<8x16xf16>, vector<8x16x2xf16> -> vector<8x16xf32>
-//       CHECK:  return %[[RES]]
-
-func.func @test(%arg1 : !xegpu.tensor_desc<8x16xf16>, %arg2 : !xegpu.tensor_desc<16x16xf16>, %arg3 : vector<16x16xf16>, %arg4 : i1) -> vector<8x16xf32> {
-  %0 = xegpu.load_nd %arg1 : !xegpu.tensor_desc<8x16xf16> -> vector<8x16xf16>
-  %1 = scf.if %arg4 -> (vector<16x16xf16>) {
-    %b = xegpu.load_nd %arg2 : !xegpu.tensor_desc<16x16xf16> -> vector<16x16xf16>
-    scf.yield %b : vector<16x16xf16>
-  } else {
-    scf.yield %arg3 : vector<16x16xf16>
-  }
-  %2 = xegpu.dpas %0, %1 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
-  return %2 : vector<8x16xf32>
-}