[Mlir-commits] [mlir] [mlir][xegpu] Make convert_layout input_layout optional (PR #210833)
Jianhui Li
llvmlistbot at llvm.org
Mon Jul 20 15:49:10 PDT 2026
https://github.com/Jianhui-Li updated https://github.com/llvm/llvm-project/pull/210833
>From 5cb9b955fbaaf28ed3a72c050251a4faa9db4c93 Mon Sep 17 00:00:00 2001
From: Jianhui Li <jian.hui.li at intel.com>
Date: Mon, 20 Jul 2026 20:32:53 +0000
Subject: [PATCH] [mlir][xegpu] Make convert_layout input_layout optional
Make the `input_layout` attribute of `xegpu.convert_layout` optional. When
it is not set, the effective input layout defaults to `target_layout`, i.e.
the source is assumed to already be in the target distribution.
- Change `$input_layout` to `OptionalAttr<DistributeLayoutAttr>` and add a
`getEffectiveInputLayout()` helper that falls back to `target_layout`.
- Update the verifier and all pass consumers (Blocking, WgToSg, SgToLane,
Unroll, PropagateLayout, Utils) to use the effective input layout.
- In PropagateLayout, guard the input_layout access with
dyn_cast_if_present since the attribute may now be null.
- In ResolveLayoutConflicts, pin the effective input layout before
retargeting a producer convert's `target_layout`, so the omitted-input
default does not silently turn a real conversion into a no-op.
- Update tests that used identical input_layout/target_layout to specify
only `target_layout`.
Co-Authored-By: Claude Opus 4.8 <noreply at anthropic.com>
---
.../include/mlir/Dialect/XeGPU/IR/XeGPUOps.td | 16 ++-
mlir/lib/Dialect/XeGPU/IR/XeGPUOps.cpp | 5 +-
.../XeGPU/Transforms/XeGPUBlocking.cpp | 2 +-
.../XeGPU/Transforms/XeGPUPropagateLayout.cpp | 12 +-
.../Transforms/XeGPUSgToLaneDistribute.cpp | 2 +-
.../Dialect/XeGPU/Transforms/XeGPUUnroll.cpp | 126 +++++++++++++++---
.../Transforms/XeGPUWgToSgDistribute.cpp | 5 +-
mlir/lib/Dialect/XeGPU/Utils/XeGPUUtils.cpp | 2 +-
.../test/Dialect/XeGPU/peephole-optimize.mlir | 5 +-
.../XeGPU/propagate-layout-inst-data.mlir | 10 +-
.../XeGPU/propagate-layout-subgroup.mlir | 3 +-
mlir/test/Dialect/XeGPU/propagate-layout.mlir | 3 +-
.../XeGPU/resolve-layout-conflicts.mlir | 6 +-
.../XeGPU/sg-to-lane-distribute-unit.mlir | 58 +-------
.../Dialect/XeGPU/sg-to-lane-distribute.mlir | 1 -
mlir/test/Dialect/XeGPU/xegpu-blocking.mlir | 36 ++++-
.../XeGPU/xegpu-wg-to-sg-elemwise.mlir | 7 -
.../test/Dialect/XeGPU/xegpu-wg-to-sg-rr.mlir | 9 --
mlir/test/Dialect/XeGPU/xegpu-wg-to-sg.mlir | 43 +-----
19 files changed, 188 insertions(+), 163 deletions(-)
diff --git a/mlir/include/mlir/Dialect/XeGPU/IR/XeGPUOps.td b/mlir/include/mlir/Dialect/XeGPU/IR/XeGPUOps.td
index 7f8389a6acc47..849b038dc1851 100644
--- a/mlir/include/mlir/Dialect/XeGPU/IR/XeGPUOps.td
+++ b/mlir/include/mlir/Dialect/XeGPU/IR/XeGPUOps.td
@@ -1227,8 +1227,9 @@ def XeGPU_ConvertLayoutOp: XeGPU_Op<"convert_layout", [AllTypesMatch<["source",
Arguments:
- `source`: The input vector whose data is to be redistributed. The source and
result types must match.
- - `input_layout`: The layout attribute describing the current distribution of `source`
- across subgroups and/or lanes.
+ - `input_layout`: [optional] The layout attribute describing the current distribution
+ of `source` across subgroups and/or lanes. When omitted, it defaults to `target_layout`,
+ i.e. the source is assumed to already be in the target distribution.
- `target_layout`: The layout attribute describing the desired distribution of the result
across subgroups and/or lanes.
@@ -1241,7 +1242,7 @@ def XeGPU_ConvertLayoutOp: XeGPU_Op<"convert_layout", [AllTypesMatch<["source",
```
}];
let arguments = (ins XeGPU_VectorOrScalarType: $source,
- DistributeLayoutAttr: $input_layout,
+ OptionalAttr<DistributeLayoutAttr>: $input_layout,
DistributeLayoutAttr: $target_layout);
let results = (outs XeGPU_VectorOrScalarType: $result);
let assemblyFormat = [{
@@ -1256,6 +1257,15 @@ def XeGPU_ConvertLayoutOp: XeGPU_Op<"convert_layout", [AllTypesMatch<["source",
setTargetLayoutAttr(anchorLayout);
}
+ /// Returns the effective input layout: the explicit `input_layout` when
+ /// set, otherwise `target_layout` (the source is assumed to already be in
+ /// the target distribution).
+ xegpu::DistributeLayoutAttr getEffectiveInputLayout() {
+ if (auto layout = getInputLayoutAttr())
+ return layout;
+ return getTargetLayoutAttr();
+ }
+
}];
let hasVerifier = 1;
diff --git a/mlir/lib/Dialect/XeGPU/IR/XeGPUOps.cpp b/mlir/lib/Dialect/XeGPU/IR/XeGPUOps.cpp
index 2ffe883eb0d9a..d6945b9c7fe3b 100644
--- a/mlir/lib/Dialect/XeGPU/IR/XeGPUOps.cpp
+++ b/mlir/lib/Dialect/XeGPU/IR/XeGPUOps.cpp
@@ -843,12 +843,11 @@ LogicalResult DpasOp::verify() {
// XeGPU_ConvertLayoutOp
//===----------------------------------------------------------------------===//
LogicalResult ConvertLayoutOp::verify() {
- auto srcLayout = getInputLayout();
auto resLayout = getTargetLayout();
- if (!srcLayout)
- return emitOpError("expected input layout.");
if (!resLayout)
return emitOpError("expected target layout.");
+ // `input_layout` is optional; when omitted it defaults to `target_layout`.
+ auto srcLayout = getEffectiveInputLayout();
// both input and target layouts should be WgLayout or SgLayout at the same
// time.
diff --git a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUBlocking.cpp b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUBlocking.cpp
index 57b8ac73f41ac..9d1686403a431 100644
--- a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUBlocking.cpp
+++ b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUBlocking.cpp
@@ -109,7 +109,7 @@ XeGPUBlockingPass::getTileShape(Operation *op) const {
if (auto convertLayoutOp = dyn_cast<xegpu::ConvertLayoutOp>(op)) {
auto inputInstData =
- convertLayoutOp.getInputLayout().getEffectiveInstDataAsInt();
+ convertLayoutOp.getEffectiveInputLayout().getEffectiveInstDataAsInt();
auto targetInstData =
convertLayoutOp.getTargetLayout().getEffectiveInstDataAsInt();
// return the one with larger size
diff --git a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUPropagateLayout.cpp b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUPropagateLayout.cpp
index 1681d295ae0ff..dc2083929e469 100644
--- a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUPropagateLayout.cpp
+++ b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUPropagateLayout.cpp
@@ -1016,8 +1016,10 @@ void LayoutInfoPropagation::visitConvertLayoutOp(
// TODO: fix if one of the layouts is a slice layout
auto targetLayoutAttr =
dyn_cast<xegpu::LayoutAttr>(convert.getTargetLayoutAttr());
+ // `input_layout` is optional; it may be null when omitted (defaults to
+ // `target_layout`), so guard against a null attribute here.
auto inputLayoutAttr =
- dyn_cast<xegpu::LayoutAttr>(convert.getInputLayoutAttr());
+ dyn_cast_if_present<xegpu::LayoutAttr>(convert.getInputLayoutAttr());
// The result's propagated layout is authoritative for the converted value.
// Fill the lane_layout / lane_data / order parameters the target_layout is
@@ -1053,7 +1055,7 @@ void LayoutInfoPropagation::visitConvertLayoutOp(
}
}
- xegpu::DistributeLayoutAttr anchorLayout = convert.getInputLayoutAttr();
+ xegpu::DistributeLayoutAttr anchorLayout = convert.getEffectiveInputLayout();
LayoutInfo convertLayout = makeLayoutInfo(anchorLayout);
// Propagate the new layout to the tensor descriptor operand.
propagateIfChanged(operands[0], operands[0]->meet(convertLayout));
@@ -1658,6 +1660,12 @@ ResolveLayoutConflicts::resolveVectorConsumer(OpOperand &operand) {
if (auto producerConvert =
vectorValue.getDefiningOp<xegpu::ConvertLayoutOp>();
producerConvert && vectorValue.hasOneUse()) {
+ // Pin the effective input layout first: when input_layout is omitted it
+ // defaults to target_layout, so retargeting target_layout below would
+ // otherwise silently change the input as well and turn a real conversion
+ // into a no-op.
+ producerConvert.setInputLayoutAttr(
+ producerConvert.getEffectiveInputLayout());
producerConvert.setTargetLayoutAttr(consumerLayout);
return success();
}
diff --git a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUSgToLaneDistribute.cpp b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUSgToLaneDistribute.cpp
index 874487da10b30..a5a998f9b4427 100644
--- a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUSgToLaneDistribute.cpp
+++ b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUSgToLaneDistribute.cpp
@@ -1673,7 +1673,7 @@ struct SgToLaneConvertLayout
LogicalResult
matchAndRewrite(xegpu::ConvertLayoutOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
- auto inputLayout = op.getInputLayoutAttr();
+ auto inputLayout = op.getEffectiveInputLayout();
auto targetLayout = op.getTargetLayoutAttr();
Type valType = op.getResult().getType();
diff --git a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUUnroll.cpp b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUUnroll.cpp
index 74c358cef90df..14061ab24ffe0 100644
--- a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUUnroll.cpp
+++ b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUUnroll.cpp
@@ -957,14 +957,98 @@ struct UnrollStoreMatrixOp : public UnrollPattern<xegpu::StoreMatrixOp> {
/// after inst_data stripped. If it does, it will unroll the vector into
/// multiple smaller vectors according to the target shape, and create multiple
/// ConvertLayoutOp with the unrolled vectors and the stripped layouts.
+///
+/// When the input and target layouts have different inst_data, the source is
+/// extracted at the input inst_data granularity and the result is inserted at
+/// the target inst_data granularity, enabling slice cancellation during
+/// canonicalization.
struct UnrollConvertLayoutOp : public UnrollPattern<xegpu::ConvertLayoutOp> {
using UnrollPattern<xegpu::ConvertLayoutOp>::UnrollPattern;
+
+ /// Extracts source in `inTile` slices, regroups into `convTile`-sized
+ /// ConvertLayoutOps, and inserts the result in `outTile` slices.
+ /// Returns failure if the tiles do not evenly divide.
+ LogicalResult
+ rewriteWithRegrouping(xegpu::ConvertLayoutOp op, VectorType valueTy,
+ ArrayRef<int64_t> convTile, ArrayRef<int64_t> inTile,
+ ArrayRef<int64_t> outTile,
+ xegpu::DistributeLayoutAttr inputLayout,
+ xegpu::DistributeLayoutAttr targetLayout, Location loc,
+ PatternRewriter &rewriter) const {
+ ArrayRef<int64_t> vecShape = valueTy.getShape();
+ if (!computeShapeRatio(vecShape, convTile) ||
+ !computeShapeRatio(convTile, inTile) ||
+ !computeShapeRatio(convTile, outTile))
+ return failure();
+
+ Type elemTy = valueTy.getElementType();
+ int64_t rank = valueTy.getRank();
+ VectorType convTy = VectorType::get(convTile, elemTy);
+ SmallVector<int64_t> strides(rank, 1);
+
+ Value source = op.getSource();
+ auto zeroOf = [&](VectorType ty) -> Value {
+ return arith::ConstantOp::create(
+ rewriter, loc, ty,
+ DenseElementsAttr::get(ty, rewriter.getZeroAttr(elemTy)));
+ };
+ auto addOffsets = [](ArrayRef<int64_t> a,
+ ArrayRef<int64_t> b) -> SmallVector<int64_t> {
+ SmallVector<int64_t> res(a);
+ for (auto [r, v] : llvm::zip_equal(res, b))
+ r += v;
+ return res;
+ };
+
+ Value result = zeroOf(valueTy);
+ for (SmallVector<int64_t> convOff :
+ StaticTileOffsetRange(vecShape, convTile)) {
+ // Build the convert tile from inTile-sized slices of the source.
+ Value conv;
+ if (convTile == inTile) {
+ conv = vector::ExtractStridedSliceOp::create(
+ rewriter, loc, source, convOff, convTile, strides);
+ } else {
+ conv = zeroOf(convTy);
+ for (SmallVector<int64_t> inLocal :
+ StaticTileOffsetRange(convTile, inTile)) {
+ Value piece = vector::ExtractStridedSliceOp::create(
+ rewriter, loc, source, addOffsets(convOff, inLocal), inTile,
+ strides);
+ conv = vector::InsertStridedSliceOp::create(rewriter, loc, piece,
+ conv, inLocal, strides);
+ }
+ }
+
+ conv = xegpu::ConvertLayoutOp::create(rewriter, loc, convTy, conv,
+ inputLayout, targetLayout);
+
+ // Write the converted tile into the result as outTile-sized slices.
+ if (convTile == outTile) {
+ result = vector::InsertStridedSliceOp::create(rewriter, loc, conv,
+ result, convOff, strides);
+ } else {
+ for (SmallVector<int64_t> outLocal :
+ StaticTileOffsetRange(convTile, outTile)) {
+ Value piece = vector::ExtractStridedSliceOp::create(
+ rewriter, loc, conv, outLocal, outTile, strides);
+ result = vector::InsertStridedSliceOp::create(
+ rewriter, loc, piece, result, addOffsets(convOff, outLocal),
+ strides);
+ }
+ }
+ }
+
+ rewriter.replaceOp(op, result);
+ return success();
+ }
+
LogicalResult matchAndRewrite(xegpu::ConvertLayoutOp op,
PatternRewriter &rewriter) const override {
Location loc = op.getLoc();
Type valType = op.getType();
- xegpu::DistributeLayoutAttr inputLayout = op.getInputLayoutAttr();
+ xegpu::DistributeLayoutAttr inputLayout = op.getEffectiveInputLayout();
xegpu::DistributeLayoutAttr targetLayout = op.getTargetLayoutAttr();
if (!inputLayout || !targetLayout)
return rewriter.notifyMatchFailure(op, "missing layout attributes.");
@@ -974,8 +1058,10 @@ struct UnrollConvertLayoutOp : public UnrollPattern<xegpu::ConvertLayoutOp> {
return success();
}
- if (inputLayout.getEffectiveInstDataAsInt().empty() ||
- targetLayout.getEffectiveInstDataAsInt().empty())
+ // Capture inst_data granularities before stripping them.
+ SmallVector<int64_t> inTile = inputLayout.getEffectiveInstDataAsInt();
+ SmallVector<int64_t> outTile = targetLayout.getEffectiveInstDataAsInt();
+ if (inTile.empty() || outTile.empty())
return rewriter.notifyMatchFailure(op, "Not a target ConvertLayoutOp.");
inputLayout = inputLayout.dropInstData();
@@ -988,20 +1074,30 @@ struct UnrollConvertLayoutOp : public UnrollPattern<xegpu::ConvertLayoutOp> {
if (!targetShape || targetShape->size() != (size_t)valueTy.getRank())
return failure();
- Value newSource = op.getSource();
+ // Nothing to convert if layouts match after stripping inst_data.
+ if (!inputLayout || !targetLayout || inputLayout.isEqualTo(targetLayout)) {
+ rewriter.replaceOp(op, op.getSource());
+ return success();
+ }
+
+ // Try regrouping: extract at inTile, convert, insert at outTile.
+ if (succeeded(rewriteWithRegrouping(op, valueTy, *targetShape, inTile,
+ outTile, inputLayout, targetLayout, loc,
+ rewriter)))
+ return success();
+
+ // Fallback: pack/unpack at the convert tile granularity.
+ SmallVector<Type> convertedValTypes =
+ getUnrolledTypes(valueTy, *targetShape);
+ SmallVector<Value> convertedValues =
+ pack(op.getOperand(), convertedValTypes, *targetShape, loc, rewriter);
SmallVector<Value> newOps;
- if (inputLayout && targetLayout && !inputLayout.isEqualTo(targetLayout)) {
- SmallVector<Type> convertedValTypes =
- getUnrolledTypes(valueTy, *targetShape);
- SmallVector<Value> convertedValues =
- pack(op.getOperand(), convertedValTypes, *targetShape, loc, rewriter);
- for (auto [v, t] : llvm::zip(convertedValues, convertedValTypes)) {
- auto newOp = xegpu::ConvertLayoutOp::create(rewriter, loc, t, v,
- inputLayout, targetLayout);
- newOps.push_back(newOp);
- }
- newSource = unpack(newOps, op.getType(), *targetShape, loc, rewriter);
+ for (auto [v, t] : llvm::zip(convertedValues, convertedValTypes)) {
+ auto newOp = xegpu::ConvertLayoutOp::create(rewriter, loc, t, v,
+ inputLayout, targetLayout);
+ newOps.push_back(newOp);
}
+ Value newSource = unpack(newOps, op.getType(), *targetShape, loc, rewriter);
rewriter.replaceOp(op, newSource);
return success();
diff --git a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUWgToSgDistribute.cpp b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUWgToSgDistribute.cpp
index 9ca6b3c2b0272..afea358dafe29 100644
--- a/mlir/lib/Dialect/XeGPU/Transforms/XeGPUWgToSgDistribute.cpp
+++ b/mlir/lib/Dialect/XeGPU/Transforms/XeGPUWgToSgDistribute.cpp
@@ -530,7 +530,7 @@ struct WgToSgConvertLayoutOp
matchAndRewrite(xegpu::ConvertLayoutOp op, OneToNOpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
Location loc = op.getLoc();
- auto inputLayout = op.getInputLayout();
+ auto inputLayout = op.getEffectiveInputLayout();
auto targetLayout = op.getTargetLayout();
if (!inputLayout || !targetLayout || !inputLayout.isForWorkgroup() ||
@@ -1661,7 +1661,8 @@ void XeGPUWgToSgDistributePass::runOnOperation() {
target.addDynamicallyLegalOp<xegpu::ConvertLayoutOp>(
[=](xegpu::ConvertLayoutOp op) -> bool {
- return isLegal(op.getInputLayout()) && isLegal(op.getTargetLayout());
+ return isLegal(op.getEffectiveInputLayout()) &&
+ isLegal(op.getTargetLayout());
});
target.addDynamicallyLegalDialect<math::MathDialect, arith::ArithDialect>(
diff --git a/mlir/lib/Dialect/XeGPU/Utils/XeGPUUtils.cpp b/mlir/lib/Dialect/XeGPU/Utils/XeGPUUtils.cpp
index 9620e21f9bfdf..07dcb438ca553 100644
--- a/mlir/lib/Dialect/XeGPU/Utils/XeGPUUtils.cpp
+++ b/mlir/lib/Dialect/XeGPU/Utils/XeGPUUtils.cpp
@@ -223,7 +223,7 @@ xegpu::getDistributeLayoutAttr(const OpOperand &opr) {
return nullptr;
}
if (auto convertOp = dyn_cast<xegpu::ConvertLayoutOp>(op)) {
- return convertOp.getInputLayoutAttr();
+ return convertOp.getEffectiveInputLayout();
}
auto layout = anchorOp.getAnchorLayout();
diff --git a/mlir/test/Dialect/XeGPU/peephole-optimize.mlir b/mlir/test/Dialect/XeGPU/peephole-optimize.mlir
index 79a6e248b0d83..fa5ff9ca56d34 100644
--- a/mlir/test/Dialect/XeGPU/peephole-optimize.mlir
+++ b/mlir/test/Dialect/XeGPU/peephole-optimize.mlir
@@ -433,7 +433,7 @@ gpu.module @xevm_test {
// CHECK: %[[REDUCE_1:.*]] = vector.multi_reduction <add>, %[[LOADED]], %[[ACC_VEC]] [0] : vector<4x16xf32> to vector<16xf32>
// CHECK: %[[REDUCE_2:.*]] = vector.multi_reduction <add>, %[[REDUCE_1]], %[[ACC_SCALAR]] [0] : vector<16xf32> to f32
// CHECK: %[[BRIDGE:.*]] = xegpu.convert_layout %[[REDUCE_2]] <{input_layout = #xegpu.slice<#xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>, dims = [0]>, target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0, 1]>}> : f32
-// CHECK: %[[CVT:.*]] = xegpu.convert_layout %[[BRIDGE]] <{input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0, 1]>, target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0, 1]>}> : f32
+// CHECK: %[[CVT:.*]] = xegpu.convert_layout %[[BRIDGE]] <{target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0, 1]>}> : f32
// CHECK: %[[BCAST:.*]] = vector.broadcast %[[CVT]] : f32 to vector<16xf32>
// CHECK: xegpu.store %[[BCAST]], %[[ARG1]]
gpu.module @xevm_test {
@@ -448,8 +448,7 @@ gpu.module @xevm_test {
{layout_result_0 = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0, 1]>}
[0, 1] : vector<4x16xf32> to f32
%cvt = xegpu.convert_layout %reduce
- <{input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0, 1]>,
- target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0, 1]>}>
+ <{target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0, 1]>}>
: f32
%reduce_bcast = vector.broadcast %cvt
{layout_result_0 = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>}
diff --git a/mlir/test/Dialect/XeGPU/propagate-layout-inst-data.mlir b/mlir/test/Dialect/XeGPU/propagate-layout-inst-data.mlir
index e8cddb8fa1de3..f684241ce0ab3 100644
--- a/mlir/test/Dialect/XeGPU/propagate-layout-inst-data.mlir
+++ b/mlir/test/Dialect/XeGPU/propagate-layout-inst-data.mlir
@@ -330,15 +330,14 @@ gpu.module @test {
// CHECK-SAME: !xegpu.tensor_desc<256x32xui8, #xegpu.layout<inst_data = [32, 16], lane_layout = [1, 16], lane_data = [1, 1]>> -> vector<256x32xui8>
// CHECK: %[[BC:.*]] = vector.bitcast %[[LOAD]] {layout_result_0 = #xegpu.layout<inst_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 2]>} : vector<256x32xui8> to vector<256x64xf4E2M1FN>
// CHECK: xegpu.convert_layout %[[BC]]
-// CHECK-SAME: <{input_layout = #xegpu.layout<inst_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 2]>, target_layout = #xegpu.layout<inst_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 2]>}>
+// CHECK-SAME: <{target_layout = #xegpu.layout<inst_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 2]>}>
// CHECK-SAME: : vector<256x64xf4E2M1FN>
func.func @bitcast_ui8_to_f4(%arg0: memref<256x32xui8>) {
%0 = xegpu.create_nd_tdesc %arg0 : memref<256x32xui8> -> !xegpu.tensor_desc<256x32xui8>
%1 = xegpu.load_nd %0[0, 0] : !xegpu.tensor_desc<256x32xui8> -> vector<256x32xui8>
%2 = vector.bitcast %1 : vector<256x32xui8> to vector<256x64xf4E2M1FN>
%3 = xegpu.convert_layout %2
- <{input_layout = #xegpu.layout<inst_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 2]>,
- target_layout = #xegpu.layout<inst_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 2]>}>
+ <{target_layout = #xegpu.layout<inst_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 2]>}>
: vector<256x64xf4E2M1FN>
return
}
@@ -353,15 +352,14 @@ gpu.module @test {
// CHECK-SAME: !xegpu.tensor_desc<256x16xui16, #xegpu.layout<inst_data = [32, 16], lane_layout = [1, 16], lane_data = [1, 1]>> -> vector<256x16xui16>
// CHECK: %[[BC:.*]] = vector.bitcast %[[LOAD]] {layout_result_0 = #xegpu.layout<inst_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 4]>} : vector<256x16xui16> to vector<256x64xf4E2M1FN>
// CHECK: xegpu.convert_layout %[[BC]]
-// CHECK-SAME: <{input_layout = #xegpu.layout<inst_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 4]>, target_layout = #xegpu.layout<inst_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 4]>}>
+// CHECK-SAME: <{target_layout = #xegpu.layout<inst_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 4]>}>
// CHECK-SAME: : vector<256x64xf4E2M1FN>
func.func @bitcast_ui16_to_f4(%arg0: memref<256x16xui16>) {
%0 = xegpu.create_nd_tdesc %arg0 : memref<256x16xui16> -> !xegpu.tensor_desc<256x16xui16>
%1 = xegpu.load_nd %0[0, 0] : !xegpu.tensor_desc<256x16xui16> -> vector<256x16xui16>
%2 = vector.bitcast %1 : vector<256x16xui16> to vector<256x64xf4E2M1FN>
%3 = xegpu.convert_layout %2
- <{input_layout = #xegpu.layout<inst_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 4]>,
- target_layout = #xegpu.layout<inst_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 4]>}>
+ <{target_layout = #xegpu.layout<inst_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 4]>}>
: vector<256x64xf4E2M1FN>
return
}
diff --git a/mlir/test/Dialect/XeGPU/propagate-layout-subgroup.mlir b/mlir/test/Dialect/XeGPU/propagate-layout-subgroup.mlir
index fa00c1d894d8f..3b4bfe3e9951e 100644
--- a/mlir/test/Dialect/XeGPU/propagate-layout-subgroup.mlir
+++ b/mlir/test/Dialect/XeGPU/propagate-layout-subgroup.mlir
@@ -373,8 +373,7 @@ gpu.module @test {
// CHECK-SAME: layout = #xegpu.layout<sg_layout = [4, 8], sg_data = [8, 16]>
%1 = xegpu.load_matrix %arg0[%c0, %c0] : !xegpu.mem_desc<32x128xf32>, index, index -> vector<32x128xf32>
%2 = xegpu.convert_layout %1
- <{input_layout = #xegpu.layout<sg_layout=[4, 8], sg_data=[8, 16]>,
- target_layout = #xegpu.layout<sg_layout=[4, 8], sg_data=[8, 16]>}>
+ <{target_layout = #xegpu.layout<sg_layout=[4, 8], sg_data=[8, 16]>}>
: vector<32x128xf32>
gpu.return
}
diff --git a/mlir/test/Dialect/XeGPU/propagate-layout.mlir b/mlir/test/Dialect/XeGPU/propagate-layout.mlir
index 79a5d229263c5..d48cb7993bfab 100644
--- a/mlir/test/Dialect/XeGPU/propagate-layout.mlir
+++ b/mlir/test/Dialect/XeGPU/propagate-layout.mlir
@@ -128,8 +128,7 @@ func.func @extf_truncf(%arg0: !xegpu.tensor_desc<8x16xf16>, %arg1: !xegpu.tensor
%3 = arith.truncf %2 : vector<16x16xf32> to vector<16x16xf16>
%4 = xegpu.dpas %0, %3 : vector<8x16xf16>, vector<16x16xf16> -> vector<8x16xf32>
%5 = xegpu.convert_layout %4
- <{input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
- target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>}>
+ <{target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>}>
: vector<8x16xf32>
return %4 : vector<8x16xf32>
}
diff --git a/mlir/test/Dialect/XeGPU/resolve-layout-conflicts.mlir b/mlir/test/Dialect/XeGPU/resolve-layout-conflicts.mlir
index 55d0e64bb2c65..6a625ff515029 100644
--- a/mlir/test/Dialect/XeGPU/resolve-layout-conflicts.mlir
+++ b/mlir/test/Dialect/XeGPU/resolve-layout-conflicts.mlir
@@ -261,8 +261,7 @@ func.func @convert_layout() {
dense<0.000000e+00>
: vector<32x128xf32>
%src0_cvt = xegpu.convert_layout %src0
- <{input_layout = #xegpu.layout<sg_layout=[8, 4], sg_data=[4, 32]>,
- target_layout = #xegpu.layout<sg_layout=[8, 4], sg_data=[4, 32]>}>
+ <{target_layout = #xegpu.layout<sg_layout=[8, 4], sg_data=[4, 32]>}>
: vector<32x128xf32>
%src1 = arith.constant
{layout_result_0 = #xegpu.layout<sg_layout = [4, 8], sg_data = [8, 16]>}
@@ -272,8 +271,7 @@ func.func @convert_layout() {
{layout_result_0 = #xegpu.layout<sg_layout = [4, 8], sg_data = [8, 16]>}
: vector<32x128xf32>
%desc_cvt = xegpu.convert_layout %dest
- <{input_layout = #xegpu.layout<sg_layout=[4, 8], sg_data=[8, 16]>,
- target_layout = #xegpu.layout<sg_layout=[4, 8], sg_data=[8, 16]>}>
+ <{target_layout = #xegpu.layout<sg_layout=[4, 8], sg_data=[8, 16]>}>
: vector<32x128xf32>
return
}
diff --git a/mlir/test/Dialect/XeGPU/sg-to-lane-distribute-unit.mlir b/mlir/test/Dialect/XeGPU/sg-to-lane-distribute-unit.mlir
index fe356e6af35c1..a338ed5de7efc 100644
--- a/mlir/test/Dialect/XeGPU/sg-to-lane-distribute-unit.mlir
+++ b/mlir/test/Dialect/XeGPU/sg-to-lane-distribute-unit.mlir
@@ -118,7 +118,6 @@ gpu.func @dpas() {
: vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
%anchor = xegpu.convert_layout %4
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<8x16xf32>
gpu.return
@@ -141,7 +140,6 @@ gpu.func @elementwise() {
: vector<16x16xf32>
%cl3 = xegpu.convert_layout %3
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<16x16xf32>
gpu.return
@@ -154,7 +152,6 @@ gpu.func @arith_constant() {
%0 = arith.constant dense<1.0> : vector<16x16xf32>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<16x16xf32>
gpu.return
@@ -176,7 +173,6 @@ gpu.func @arith_constant_non_splat() {
dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<16xindex>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>
}> : vector<16xindex>
gpu.return
@@ -200,7 +196,6 @@ gpu.func @arith_constant_non_splat_lane_data() {
dense<[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<32xindex>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 2]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 2]>, dims = [0]>
}> : vector<32xindex>
gpu.return
@@ -239,7 +234,6 @@ gpu.func @arith_constant_non_splat_2d_vertical_lanedata() {
[96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]]> : vector<4x32xindex>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [2, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [2, 1]>
}> : vector<4x32xindex>
gpu.return
@@ -377,7 +371,6 @@ gpu.func @vector_reduction() {
%2 = vector.reduction <add>, %0, %acc : vector<32xf32> into f32
%anchor = xegpu.convert_layout %2
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16], lane_data = [1]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16], lane_data = [1]>, dims = [0]>
}> : f32
gpu.return
@@ -440,7 +433,6 @@ gpu.func @vector_multi_reduction_dim1_distributed_dim1_reduction(%laneid: index)
[1] : vector<2x16xf32> to vector<2xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [1]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [1]>
}> : vector<2xf32>
gpu.return
@@ -503,7 +495,6 @@ gpu.func @vector_multi_reduction_dim0_distributed_dim0_reduction(%laneid: index)
[0] : vector<16x2xf32> to vector<2xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16, 1], lane_data = [1, 1]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16, 1], lane_data = [1, 1]>, dims = [0]>
}> : vector<2xf32>
gpu.return
@@ -526,7 +517,6 @@ gpu.func @vector_multi_reduction_dim1_distributed_dim0_reduction(%laneid: index)
[0] : vector<4x16xf32> to vector<16xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>
}> : vector<16xf32>
gpu.return
@@ -549,7 +539,6 @@ gpu.func @vector_multi_reduction_dim0_distributed_dim1_reduction(%laneid: index)
[1] : vector<16x12xf32> to vector<16xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16, 1], lane_data = [1, 1]>, dims = [1]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16, 1], lane_data = [1, 1]>, dims = [1]>
}> : vector<16xf32>
gpu.return
@@ -567,7 +556,6 @@ gpu.func @vector_transpose() {
: vector<16x2xf32> to vector<2x16xf32>
%transpose2 = xegpu.convert_layout %transpose
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<2x16xf32>
gpu.return
@@ -583,7 +571,6 @@ gpu.func @vector_bitcast() {
%bitcast = vector.bitcast %cst : vector<4x32xi8> to vector<4x16xi16>
%anchor = xegpu.convert_layout %bitcast
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<4x16xi16>
gpu.return
@@ -602,7 +589,6 @@ gpu.func @create_mask_1d(%m0: index) {
: vector<16xi1>
%mask_cl = xegpu.convert_layout %mask
<{
- input_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>,
target_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>
}> : vector<16xi1>
gpu.return
@@ -621,7 +607,6 @@ gpu.func @constant_mask_1d() {
: vector<16xi1>
%mask_cl = xegpu.convert_layout %mask
<{
- input_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>,
target_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>
}> : vector<16xi1>
gpu.return
@@ -646,7 +631,6 @@ gpu.func @create_mask_2d(%m0: index, %m1: index) {
: vector<8x4xi1>
%mask_cl = xegpu.convert_layout %mask
<{
- input_layout = #xegpu.layout<lane_layout = [8, 2], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [8, 2], lane_data = [1, 1]>
}> : vector<8x4xi1>
gpu.return
@@ -672,7 +656,6 @@ gpu.func @constant_mask_2d() {
: vector<8x4xi1>
%mask_cl = xegpu.convert_layout %mask
<{
- input_layout = #xegpu.layout<lane_layout = [8, 2], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [8, 2], lane_data = [1, 1]>
}> : vector<8x4xi1>
gpu.return
@@ -699,7 +682,6 @@ gpu.func @vector_multi_reduction_3d_leading_unit_dim_lane_local() {
[1] : vector<1x16x32xf32> to vector<1x32xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 1, 16], lane_data = [1, 1, 1]>, dims = [1]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 1, 16], lane_data = [1, 1, 1]>, dims = [1]>
}> : vector<1x32xf32>
gpu.return
@@ -730,7 +712,6 @@ gpu.func @vector_multi_reduction_3d_leading_unit_dim_cross_lane() {
[1] : vector<1x16x2xf32> to vector<1x2xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16, 1], lane_data = [1, 1, 1]>, dims = [1]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16, 1], lane_data = [1, 1, 1]>, dims = [1]>
}> : vector<1x2xf32>
gpu.return
@@ -744,7 +725,6 @@ gpu.func @vector_extract_from_2d() {
: vector<16xf32> from vector<4x16xf32>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>,
target_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>
}> : vector<16xf32>
gpu.return
@@ -759,7 +739,6 @@ gpu.func @vector_extract_from_2d_offset2() {
: vector<16xf32> from vector<8x16xf32>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>,
target_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>
}> : vector<16xf32>
gpu.return
@@ -776,7 +755,6 @@ gpu.func @vector_insert_into_2d() {
: vector<16xf32> into vector<4x16xf32>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<4x16xf32>
gpu.return
@@ -793,7 +771,6 @@ gpu.func @vector_insert_into_2d_offset2() {
: vector<16xf32> into vector<8x16xf32>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<8x16xf32>
gpu.return
@@ -809,7 +786,6 @@ gpu.func @vector_extract_strided_slice_distributed_dim_fully_extracted() {
: vector<24x16xf32> to vector<8x16xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<8x16xf32>
gpu.return
@@ -825,7 +801,6 @@ gpu.func @vector_extract_strided_slice_inner_distributed() {
: vector<24x64xf32> to vector<8x16xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<8x16xf32>
gpu.return
@@ -841,7 +816,6 @@ gpu.func @vector_extract_strided_slice_outer_distributed() {
: vector<32x16xf32> to vector<16x16xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.layout<lane_layout = [16, 1], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [16, 1], lane_data = [1, 1]>
}> : vector<16x16xf32>
gpu.return
@@ -857,7 +831,6 @@ gpu.func @vector_extract_strided_slice_1d() {
: vector<64xf32> to vector<32xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>,
target_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>
}> : vector<32xf32>
gpu.return
@@ -873,7 +846,6 @@ gpu.func @vector_extract_strided_slice_partial_offsets() {
: vector<24x16xf32> to vector<8x16xf32>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<8x16xf32>
gpu.return
@@ -913,22 +885,18 @@ gpu.func @convert_layout_repack_lane_data() {
: vector<32x16xi8> to vector<8x16xi8>
%a0 = xegpu.convert_layout %s0
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1], order = [1, 0]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1], order = [1, 0]>
}> : vector<8x16xi8>
%a1 = xegpu.convert_layout %s1
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1], order = [1, 0]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1], order = [1, 0]>
}> : vector<8x16xi8>
%a2 = xegpu.convert_layout %s2
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1], order = [1, 0]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1], order = [1, 0]>
}> : vector<8x16xi8>
%a3 = xegpu.convert_layout %s3
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1], order = [1, 0]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1], order = [1, 0]>
}> : vector<8x16xi8>
gpu.return
@@ -946,7 +914,6 @@ gpu.func @vector_insert_strided_slice_distributed_dim_fully_inserted() {
: vector<16x16xf32> into vector<64x16xf32>
%cl2 = xegpu.convert_layout %2
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<64x16xf32>
gpu.return
@@ -964,7 +931,6 @@ gpu.func @vector_insert_strided_slice_inner_distributed() {
: vector<16x16xf32> into vector<64x32xf32>
%cl2 = xegpu.convert_layout %2
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<64x32xf32>
gpu.return
@@ -982,7 +948,6 @@ gpu.func @vector_insert_strided_slice_outer_distributed() {
: vector<16x16xf32> into vector<48x32xf32>
%cl2 = xegpu.convert_layout %2
<{
- input_layout = #xegpu.layout<lane_layout = [16, 1], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [16, 1], lane_data = [1, 1]>
}> : vector<48x32xf32>
gpu.return
@@ -1000,7 +965,6 @@ gpu.func @vector_insert_strided_slice_1d() {
: vector<16xf32> into vector<48xf32>
%cl2 = xegpu.convert_layout %2
<{
- input_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>,
target_layout = #xegpu.layout<lane_layout = [16], lane_data = [1]>
}> : vector<48xf32>
gpu.return
@@ -1018,7 +982,6 @@ gpu.func @vector_insert_strided_slice_different_ranks() {
: vector<16xf32> into vector<64x16xf32>
%cl2 = xegpu.convert_layout %2
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<64x16xf32>
gpu.return
@@ -1054,8 +1017,7 @@ gpu.module @xevm_module {
gpu.func @convert_layout_scalar() {
%0 = "some_op"() : () -> f32
%1 = xegpu.convert_layout %0
- <{input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16], lane_data = [1]>, dims = [0]>,
- target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16], lane_data = [1]>, dims = [0]>}>
+ <{target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16], lane_data = [1]>, dims = [0]>}>
: f32
"some_use"(%1) : (f32) -> ()
gpu.return
@@ -1139,7 +1101,6 @@ gpu.func @elementwise_wrap_around_dim() {
: vector<16x1xf16>
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<16x1xf16>
gpu.return
@@ -1158,7 +1119,6 @@ gpu.func @vector_step_slice() {
%0 = vector.step : vector<16xindex>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 1, 1, 16], lane_data = [1, 1, 1, 1]>, dims = [0, 1, 2]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 1, 1, 16], lane_data = [1, 1, 1, 1]>, dims = [0, 1, 2]>
}> : vector<16xindex>
gpu.return
@@ -1173,7 +1133,6 @@ gpu.func @vector_step_slice_unit() {
%0 = vector.step : vector<1xindex>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 1, 1, 16], lane_data = [1, 1, 1, 1]>, dims = [0, 1, 3]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 1, 1, 16], lane_data = [1, 1, 1, 1]>, dims = [0, 1, 3]>
}> : vector<1xindex>
gpu.return
@@ -1195,7 +1154,6 @@ gpu.func @vector_step_slice_multi_dist() {
%0 = vector.step : vector<16xindex>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [2, 4, 2], lane_data = [1, 2, 1]>, dims = [0, 2]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [2, 4, 2], lane_data = [1, 2, 1]>, dims = [0, 2]>
}> : vector<16xindex>
gpu.return
@@ -1213,7 +1171,6 @@ gpu.func @vector_shapecast_rank_increasing() {
: vector<16xf32> to vector<1x16xf32>
%cast_cl = xegpu.convert_layout %cast
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<1x16xf32>
gpu.return
@@ -1231,7 +1188,6 @@ gpu.func @vector_shapecast_rank_reducing() {
: vector<1x16xf32> to vector<16xf32>
%cast_cl = xegpu.convert_layout %cast
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>
}> : vector<16xf32>
gpu.return
@@ -1249,7 +1205,6 @@ gpu.func @vector_shapecast_rank_increasing_without_slicing_layout() {
: vector<16xf32> to vector<1x16xf32>
%cast_cl = xegpu.convert_layout %cast
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<1x16xf32>
gpu.return
@@ -1267,7 +1222,6 @@ gpu.func @vector_broadcast_1d_to_2d(%laneid: index) {
%1 = vector.broadcast %0 : vector<16xf16> to vector<16x16xf16>
%anchor = xegpu.convert_layout %1
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<16x16xf16>
gpu.return
@@ -1283,7 +1237,6 @@ gpu.func @constant_wrap_around_dim() {
%0 = arith.constant dense<1.0> : vector<16x1xf16>
%cl0 = xegpu.convert_layout %0
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<16x1xf16>
gpu.return
@@ -1301,7 +1254,6 @@ gpu.func @vector_broadcast_2d_to_3d(%laneid: index) {
%1 = vector.broadcast %0 : vector<16x16xf16> to vector<1x16x16xf16>
%2 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.layout<lane_layout = [1, 1, 16], lane_data = [1, 1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 1, 16], lane_data = [1, 1, 1]>
}> : vector<1x16x16xf16>
"some_use"(%2) : (vector<1x16x16xf16>) -> ()
@@ -1317,7 +1269,7 @@ gpu.module @xevm_module {
gpu.func @vector_broadcast_2d_to_2d_noop(%laneid: index) {
%0 = "some_op"() : () -> vector<16x1xf16>
%1 = vector.broadcast %0 : vector<16x1xf16> to vector<16x16xf16>
- %2 = xegpu.convert_layout %1 <{input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>}> : vector<16x16xf16>
+ %2 = xegpu.convert_layout %1 <{target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>}> : vector<16x16xf16>
"some_use"(%2) : (vector<16x16xf16>) -> ()
gpu.return
}
@@ -1332,7 +1284,7 @@ gpu.module @xevm_module {
gpu.func @vector_broadcast_scalar_to_vector(%laneid: index) {
%0 = "some_op"() : () -> f16
%1 = vector.broadcast %0 : f16 to vector<16x16xf16>
- %2 = xegpu.convert_layout %1 <{input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>}> : vector<16x16xf16>
+ %2 = xegpu.convert_layout %1 <{target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>}> : vector<16x16xf16>
"some_use"(%2) : (vector<16x16xf16>) -> ()
gpu.return
}
@@ -1379,7 +1331,6 @@ gpu.func @vector_multi_reduction_1d_to_scalar() {
[0] : vector<32xf32> to f32
%cl1 = xegpu.convert_layout %1
<{
- input_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16], lane_data = [1]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<lane_layout = [16], lane_data = [1]>, dims = [0]>
}> : f32
gpu.return
@@ -1400,7 +1351,6 @@ gpu.func @vector_interleave() {
%cl1 = xegpu.convert_layout %2
<{
- input_layout = #xegpu.layout<lane_layout = [8, 2], lane_data = [1, 2]>,
target_layout = #xegpu.layout<lane_layout = [8, 2], lane_data = [1, 2]>
}> : vector<8x4xf32>
@@ -1419,7 +1369,6 @@ gpu.func @vector_deinterleave() {
%cl1 = xegpu.convert_layout %even
<{
- input_layout = #xegpu.layout<lane_layout = [8, 2], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [8, 2], lane_data = [1, 1]>
}> : vector<8x2xf32>
@@ -1455,7 +1404,6 @@ gpu.func @xegpu_dpas_mx(%arg0: !xegpu.mem_desc<8x8xf16>, %arg1: !xegpu.mem_desc<
%anchor = xegpu.convert_layout %4
<{
- input_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<8x16xf32>
gpu.return
diff --git a/mlir/test/Dialect/XeGPU/sg-to-lane-distribute.mlir b/mlir/test/Dialect/XeGPU/sg-to-lane-distribute.mlir
index fa9897770a08e..9eed7160c0baa 100644
--- a/mlir/test/Dialect/XeGPU/sg-to-lane-distribute.mlir
+++ b/mlir/test/Dialect/XeGPU/sg-to-lane-distribute.mlir
@@ -484,7 +484,6 @@ gpu.module @xevm_module {
%4 = vector.reduction <add>, %3 : vector<16xf32> into f32
%anchor = xegpu.convert_layout %4
<{
- input_layout = #xegpu.slice<#xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>, dims=[0]>,
target_layout = #xegpu.slice<#xegpu.slice<#xegpu.layout<lane_layout = [1, 16], lane_data = [1, 1]>, dims = [0]>, dims=[0]>
}>
: f32
diff --git a/mlir/test/Dialect/XeGPU/xegpu-blocking.mlir b/mlir/test/Dialect/XeGPU/xegpu-blocking.mlir
index b0b16c2adba6e..ea6d3604ac0d3 100644
--- a/mlir/test/Dialect/XeGPU/xegpu-blocking.mlir
+++ b/mlir/test/Dialect/XeGPU/xegpu-blocking.mlir
@@ -424,7 +424,7 @@ gpu.module @test_kernel {
%a_tdesc = xegpu.create_nd_tdesc %arg0 : memref<16x16xf16> -> !xegpu.tensor_desc<16x16xf16, #a>
%a = xegpu.load_nd %a_tdesc[0, 0] {layout = #a}: !xegpu.tensor_desc<16x16xf16, #a> -> vector<16x16xf16>
%a_reduce = vector.multi_reduction <add>, %a, %acc [0, 1] : vector<16x16xf16> to f16
- %13 = xegpu.convert_layout %a_reduce <{input_layout = #xegpu.slice<#a, dims = [0, 1]>, target_layout = #xegpu.slice<#a, dims = [0, 1]>}> : f16
+ %13 = xegpu.convert_layout %a_reduce <{target_layout = #xegpu.slice<#a, dims = [0, 1]>}> : f16
memref.store %13, %arg1[%c0] : memref<4xf16>
gpu.return
}
@@ -463,19 +463,19 @@ gpu.module @test_kernel {
//CHECK: gpu.func @convert_layout([[arg0:%.+]]: vector<8x32x2xf16>) -> vector<8x32x2xf16> {
//CHECK: [[cst:%.+]] = arith.constant dense<0.000000e+00> : vector<8x32x2xf16>
//CHECK: [[e0:%.+]] = vector.extract_strided_slice [[arg0]] {offsets = [0, 0, 0], sizes = [4, 32, 2], strides = [1, 1, 1]} : vector<8x32x2xf16> to vector<4x32x2xf16>
- //CHECK: [[e1:%.+]] = vector.extract_strided_slice [[arg0]] {offsets = [4, 0, 0], sizes = [4, 32, 2], strides = [1, 1, 1]} : vector<8x32x2xf16> to vector<4x32x2xf16>
//CHECK: [[c0:%.+]] = xegpu.convert_layout [[e0]] <{input_layout = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 2]>, target_layout = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 1]>}> : vector<4x32x2xf16>
- //CHECK: [[c1:%.+]] = xegpu.convert_layout [[e1]] <{input_layout = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 2]>, target_layout = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 1]>}> : vector<4x32x2xf16>
//CHECK: [[e2:%.+]] = vector.extract_strided_slice [[c0]] {offsets = [0, 0, 0], sizes = [4, 16, 2], strides = [1, 1, 1]} : vector<4x32x2xf16> to vector<4x16x2xf16>
+ //CHECK: [[e3:%.+]] = vector.extract_strided_slice [[c0]] {offsets = [0, 16, 0], sizes = [4, 16, 2], strides = [1, 1, 1]} : vector<4x32x2xf16> to vector<4x16x2xf16>
+ //CHECK: [[e1:%.+]] = vector.extract_strided_slice [[arg0]] {offsets = [4, 0, 0], sizes = [4, 32, 2], strides = [1, 1, 1]} : vector<8x32x2xf16> to vector<4x32x2xf16>
+ //CHECK: [[c1:%.+]] = xegpu.convert_layout [[e1]] <{input_layout = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 2]>, target_layout = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 1]>}> : vector<4x32x2xf16>
+ //CHECK: [[e4:%.+]] = vector.extract_strided_slice [[c1]] {offsets = [0, 0, 0], sizes = [4, 16, 2], strides = [1, 1, 1]} : vector<4x32x2xf16> to vector<4x16x2xf16>
+ //CHECK: [[e5:%.+]] = vector.extract_strided_slice [[c1]] {offsets = [0, 16, 0], sizes = [4, 16, 2], strides = [1, 1, 1]} : vector<4x32x2xf16> to vector<4x16x2xf16>
//CHECK: [[m0:%.+]] = math.exp [[e2]] {layout_result_0 = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 1]>} : vector<4x16x2xf16>
//CHECK: [[i0:%.+]] = vector.insert_strided_slice [[m0]], [[cst]] {offsets = [0, 0, 0], strides = [1, 1, 1]} : vector<4x16x2xf16> into vector<8x32x2xf16>
- //CHECK: [[e3:%.+]] = vector.extract_strided_slice [[c0]] {offsets = [0, 16, 0], sizes = [4, 16, 2], strides = [1, 1, 1]} : vector<4x32x2xf16> to vector<4x16x2xf16>
//CHECK: [[m1:%.+]] = math.exp [[e3]] {layout_result_0 = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 1]>} : vector<4x16x2xf16>
//CHECK: [[i1:%.+]] = vector.insert_strided_slice [[m1]], [[i0]] {offsets = [0, 16, 0], strides = [1, 1, 1]} : vector<4x16x2xf16> into vector<8x32x2xf16>
- //CHECK: [[e4:%.+]] = vector.extract_strided_slice [[c1]] {offsets = [0, 0, 0], sizes = [4, 16, 2], strides = [1, 1, 1]} : vector<4x32x2xf16> to vector<4x16x2xf16>
//CHECK: [[m2:%.+]] = math.exp [[e4]] {layout_result_0 = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 1]>} : vector<4x16x2xf16>
//CHECK: [[i2:%.+]] = vector.insert_strided_slice [[m2]], [[i1]] {offsets = [4, 0, 0], strides = [1, 1, 1]} : vector<4x16x2xf16> into vector<8x32x2xf16>
- //CHECK: [[e5:%.+]] = vector.extract_strided_slice [[c1]] {offsets = [0, 16, 0], sizes = [4, 16, 2], strides = [1, 1, 1]} : vector<4x32x2xf16> to vector<4x16x2xf16>
//CHECK: [[m3:%.+]] = math.exp [[e5]] {layout_result_0 = #xegpu.layout<lane_layout = [1, 16, 1], lane_data = [4, 1, 1]>} : vector<4x16x2xf16>
//CHECK: [[i3:%.+]] = vector.insert_strided_slice [[m3]], [[i2]] {offsets = [4, 16, 0], strides = [1, 1, 1]} : vector<4x16x2xf16> into vector<8x32x2xf16>
//CHECK: gpu.return [[i3]] : vector<8x32x2xf16>
@@ -483,11 +483,33 @@ gpu.module @test_kernel {
gpu.func @convert_layout(%B: vector<8x32x2xf16>) -> vector<8x32x2xf16> {
%b = xegpu.convert_layout %B <{input_layout = #lb, target_layout = #b}> : vector<8x32x2xf16>
%e = math.exp %b : vector<8x32x2xf16>
- %anchor = xegpu.convert_layout %e <{input_layout = #b, target_layout = #b}> : vector<8x32x2xf16>
+ %anchor = xegpu.convert_layout %e <{target_layout = #b}> : vector<8x32x2xf16>
gpu.return %e : vector<8x32x2xf16>
}
}
+// -----
+
+// Test regrouping when input and target inst_data differ ([8, 16] vs [8, 64]).
+#in = #xegpu.layout<inst_data = [8, 16], lane_layout = [1, 16], lane_data = [1, 1]>
+#tgt = #xegpu.layout<inst_data = [8, 64], lane_layout = [1, 16], lane_data = [1, 4]>
+
+gpu.module @test_kernel {
+ //CHECK-LABEL: gpu.func @convert_layout_regroup
+ //CHECK-SAME: ([[arg0:%.+]]: vector<16x64xbf16>)
+ //CHECK: vector.extract_strided_slice [[arg0]] {offsets = [0, 0], sizes = [8, 16]
+ //CHECK: math.exp {{.*}} : vector<8x16xbf16>
+ //CHECK-NOT: vector.extract_strided_slice [[arg0]] {{.*}}sizes = [8, 64]
+ //CHECK: vector.insert_strided_slice {{.*}} : vector<8x16xbf16> into vector<8x64xbf16>
+ //CHECK: xegpu.convert_layout {{.*}} : vector<8x64xbf16>
+ //CHECK: vector.insert_strided_slice {{.*}} : vector<8x64xbf16> into vector<16x64xbf16>
+ gpu.func @convert_layout_regroup(%a: vector<16x64xbf16>) -> vector<16x64xbf16> {
+ %p = math.exp %a {layout_result_0 = #in} : vector<16x64xbf16>
+ %0 = xegpu.convert_layout %p <{input_layout = #in, target_layout = #tgt}> : vector<16x64xbf16>
+ gpu.return %0 : vector<16x64xbf16>
+ }
+}
+
// -----
gpu.module @test_kernel {
//CHECK-LABEL: unroll_load_matrix
diff --git a/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg-elemwise.mlir b/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg-elemwise.mlir
index 3e8d183242a91..918d587f12db5 100644
--- a/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg-elemwise.mlir
+++ b/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg-elemwise.mlir
@@ -15,7 +15,6 @@ gpu.module @test_elementwise_ops {
: vector<24x32xf32>
%anchor = xegpu.convert_layout %negf
<{
- input_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8]>,
target_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8]>
}> : vector<24x32xf32>
gpu.return
@@ -34,7 +33,6 @@ gpu.module @test_elementwise_ops {
: vector<24x32xf32>
%anchor = xegpu.convert_layout %negf
<{
- input_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>
}> : vector<24x32xf32>
gpu.return
@@ -54,7 +52,6 @@ gpu.module @test_elementwise_ops {
%powf = math.powf %addf, %load_b : vector<24x32xf32>
%anchor = xegpu.convert_layout %powf
<{
- input_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>
}> : vector<24x32xf32>
gpu.return
@@ -79,7 +76,6 @@ gpu.module @test_elementwise_ops {
: vector<24x32xf32>
%anchor = xegpu.convert_layout %fma
<{
- input_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>
}> : vector<24x32xf32>
gpu.return
@@ -101,7 +97,6 @@ gpu.module @test_elementwise_ops {
: vector<24x32xf16> to vector<24x32xi16>
%anchor = xegpu.convert_layout %bitcast
<{
- input_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>
}> : vector<24x32xi16>
gpu.return
@@ -130,7 +125,6 @@ gpu.module @test_elementwise_ops {
%res = arith.select %cmpi, %cmpi, %cmpf : vector<24x32xi1>, vector<24x32xi1>
%anchor = xegpu.convert_layout %res
<{
- input_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [2, 4], sg_data = [12, 8], lane_layout = [2, 8], lane_data = [1, 1]>
}> : vector<24x32xi1>
gpu.return
@@ -155,7 +149,6 @@ gpu.module @test_elementwise_ops {
: vector<24x32xf32>
%anchor = xegpu.convert_layout %powf
<{
- input_layout = #xegpu.layout<sg_layout = [4, 4], sg_data = [2, 2], lane_layout = [2, 2], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [4, 4], sg_data = [2, 2], lane_layout = [2, 2], lane_data = [1, 1]>
}> : vector<24x32xf32>
gpu.return
diff --git a/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg-rr.mlir b/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg-rr.mlir
index 819937d3ec86c..2969e551d93cb 100644
--- a/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg-rr.mlir
+++ b/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg-rr.mlir
@@ -93,7 +93,6 @@ gpu.module @test_distribution {
: vector<256x64xf32> to vector<256xf32>
%anchor = xegpu.convert_layout %reduce
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [8, 1], sg_data = [16, 64]>, dims = [1]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [8, 1], sg_data = [16, 64]>, dims = [1]>
}> : vector<256xf32>
gpu.return
@@ -123,7 +122,6 @@ gpu.module @test_distribution {
%cst_2 = arith.constant dense<[[0], [16], [32], [48], [64], [80], [96], [112], [128], [144], [160], [176], [192], [208], [224], [240], [256], [272], [288], [304], [320], [336], [352], [368], [384], [400], [416], [432], [448], [464], [480], [496]]> : vector<32x1xindex>
%anchor = xegpu.convert_layout %cst_2
<{
- input_layout = #xegpu.layout<sg_layout = [8, 1], sg_data = [2, 1]>,
target_layout = #xegpu.layout<sg_layout = [8, 1], sg_data = [2, 1]>
}> : vector<32x1xindex>
gpu.return
@@ -142,7 +140,6 @@ gpu.module @test_distribution {
: vector<256x128xf32> to vector<128x256xf32>
%anchor = xegpu.convert_layout %trans
<{
- input_layout = #xegpu.layout<sg_layout = [4, 8], sg_data = [16, 32], lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [4, 8], sg_data = [16, 32], lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<128x256xf32>
gpu.return
@@ -155,7 +152,6 @@ gpu.module @test_distribution {
%constant_mask = vector.constant_mask [16, 16] : vector<256x128xi1>
%anchor = xegpu.convert_layout %constant_mask
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [16, 16]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [16, 16]>
}> : vector<256x128xi1>
gpu.return
@@ -168,7 +164,6 @@ gpu.module @test_distribution {
%constant_mask = vector.create_mask %cst16, %cst16 : vector<256x128xi1>
%anchor = xegpu.convert_layout %constant_mask
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [16, 16]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [16, 16]>
}> : vector<256x128xi1>
gpu.return
@@ -241,7 +236,6 @@ gpu.module @test_distribution {
%reduce = vector.multi_reduction <add>, %val, %acc [1] : vector<8x256xf32> to vector<8xf32>
%anchor = xegpu.convert_layout %reduce
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [1, 16], sg_data = [4, 16]>, dims = [1]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [1, 16], sg_data = [4, 16]>, dims = [1]>
}> : vector<8xf32>
gpu.return
@@ -253,7 +247,6 @@ gpu.module @test_distribution {
%cst_2 = arith.constant dense<0> : vector<8xindex>
%anchor = xegpu.convert_layout %cst_2
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [16, 1], sg_data = [16, 4], order = [0, 1]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [16, 1], sg_data = [16, 4], order = [0, 1]>, dims = [0]>
}> : vector<8xindex>
gpu.return
@@ -277,7 +270,6 @@ gpu.module @test_distribution {
%bcast = vector.broadcast %2 : vector<8xindex> to vector<256x8xindex>
%anchor = xegpu.convert_layout %bcast
<{
- input_layout = #xegpu.layout<sg_layout = [16, 1], sg_data = [16, 4]>,
target_layout = #xegpu.layout<sg_layout = [16, 1], sg_data = [16, 4]>
}> : vector<256x8xindex>
gpu.return
@@ -306,7 +298,6 @@ gpu.module @test_distribution {
: vector<128x1xf32> to vector<128x64xf32>
%anchor = xegpu.convert_layout %broadcast
<{
- input_layout = #xegpu.layout<sg_layout = [4, 1], sg_data = [16, 32], lane_layout = [8, 1], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [4, 1], sg_data = [16, 32], lane_layout = [8, 1], lane_data = [1, 1]>
}> : vector<128x64xf32>
gpu.return
diff --git a/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg.mlir b/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg.mlir
index 8c5dd6c55b99d..cdc9392f02e04 100644
--- a/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg.mlir
+++ b/mlir/test/Dialect/XeGPU/xegpu-wg-to-sg.mlir
@@ -164,8 +164,7 @@ gpu.module @test_distribution {
%broadcast = vector.broadcast %load
: vector<256x1xf32> to vector<256x32xf32>
%anchor = xegpu.convert_layout %broadcast
- <{input_layout = #xegpu.layout<sg_layout = [8, 1], sg_data = [32, 32], lane_layout = [8, 1], lane_data = [1, 1]>,
- target_layout = #xegpu.layout<sg_layout = [8, 1], sg_data = [32, 32], lane_layout = [8, 1], lane_data = [1, 1]>}>
+ <{target_layout = #xegpu.layout<sg_layout = [8, 1], sg_data = [32, 32], lane_layout = [8, 1], lane_data = [1, 1]>}>
: vector<256x32xf32>
gpu.return
}
@@ -183,7 +182,6 @@ gpu.module @test_distribution {
: vector<1x128xf32> to vector<32x128xf32>
%anchor = xegpu.convert_layout %broadcast
<{
- input_layout = #xegpu.layout<sg_layout = [1, 4], sg_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [1, 4], sg_data = [32, 32], lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<32x128xf32>
gpu.return
@@ -270,7 +268,6 @@ gpu.module @test_distribution {
%exp = math.exp %load : vector<128x64xf32>
%anchor = xegpu.convert_layout %exp
<{
- input_layout = #xegpu.layout<sg_layout = [4, 4], sg_data = [32, 16], lane_layout = [8, 4], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [4, 4], sg_data = [32, 16], lane_layout = [8, 4], lane_data = [1, 1]>
}> : vector<128x64xf32>
}{sg_id_range = #xegpu.range<[2, 18]>}
@@ -304,7 +301,6 @@ gpu.module @test_distribution {
%exp = math.exp %ld : vector<128x64xf32>
%anchor = xegpu.convert_layout %exp
<{
- input_layout = #xegpu.layout<sg_layout = [4, 4], sg_data = [32, 16], lane_layout = [8, 4], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [4, 4], sg_data = [32, 16], lane_layout = [8, 4], lane_data = [1, 1]>
}> : vector<128x64xf32>
}
@@ -419,8 +415,7 @@ gpu.module @test_distribution {
%reduce = vector.multi_reduction <add>, %load, %cst [0]
: vector<4x128xf32> to vector<128xf32>
%anchor = xegpu.convert_layout %reduce
- <{input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [1, 32], sg_data = [4, 4]>, dims = [0]>,
- target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [1, 32], sg_data = [4, 4]>, dims = [0]>}>
+ <{target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [1, 32], sg_data = [4, 4]>, dims = [0]>}>
: vector<128xf32>
gpu.return
}
@@ -437,8 +432,7 @@ gpu.module @test_distribution {
%reduce = vector.multi_reduction <add>, %load, %cst [1]
: vector<256x64xf32> to vector<256xf32>
%anchor = xegpu.convert_layout %reduce
- <{input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [16, 1], sg_data = [16, 64]>, dims = [1]>,
- target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [16, 1], sg_data = [16, 64]>, dims = [1]>}>
+ <{target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [16, 1], sg_data = [16, 64]>, dims = [1]>}>
: vector<256xf32>
gpu.return
}
@@ -454,7 +448,6 @@ gpu.module @test_distribution {
: vector<4x2x6x32xf16> to vector<4x2x6xf16>
%anchor = xegpu.convert_layout %reduce
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [4, 2, 6, 1], sg_data = [1, 1, 1, 32]>, dims = [3]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [4, 2, 6, 1], sg_data = [1, 1, 1, 32]>, dims = [3]>
}> : vector<4x2x6xf16>
gpu.return
@@ -483,7 +476,6 @@ gpu.module @test_distribution {
: vector<32x32xf32> to f32
%anchor = xegpu.convert_layout %reduce
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [4, 4], sg_data = [8, 8]>, dims = [0, 1]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [4, 4], sg_data = [8, 8]>, dims = [0, 1]>
}> : f32
gpu.return
@@ -507,7 +499,6 @@ gpu.module @test_distribution {
%step = vector.step : vector<128xindex>
%anchor = xegpu.convert_layout %step
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [4, 8], sg_data = [32, 32]>, dims = [1]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [4, 8], sg_data = [32, 32]>, dims = [1]>
}> : vector<128xindex>
gpu.return
@@ -527,7 +518,6 @@ gpu.module @test_distribution {
%step = vector.step : vector<128xindex>
%anchor = xegpu.convert_layout %step
<{
- input_layout = #xegpu.layout<sg_layout = [16], sg_data = [8]>,
target_layout = #xegpu.layout<sg_layout = [16], sg_data = [8]>
}> : vector<128xindex>
gpu.return
@@ -539,7 +529,6 @@ gpu.module @test_distribution {
%cst = arith.constant dense<10> : vector<4xindex>
%anchor = xegpu.convert_layout %cst
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [4, 2, 6, 1], sg_data = [1, 1, 1, 1]>, dims = [1, 2, 3]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [4, 2, 6, 1], sg_data = [1, 1, 1, 1]>, dims = [1, 2, 3]>
}> : vector<4xindex>
gpu.return
@@ -554,7 +543,6 @@ gpu.module @test_distribution {
%shape_cast = vector.shape_cast %muli : vector<128xindex> to vector<1x1x1x128xindex>
%anchor = xegpu.convert_layout %shape_cast
<{
- input_layout = #xegpu.layout<sg_layout = [8, 1, 1, 4], sg_data = [1, 1, 1, 32]>,
target_layout = #xegpu.layout<sg_layout = [8, 1, 1, 4], sg_data = [1, 1, 1, 32]>
}> : vector<1x1x1x128xindex>
gpu.return
@@ -567,7 +555,6 @@ gpu.module @test_distribution {
%broadcast = vector.broadcast %muli : index to vector<4x2x6x32xindex>
%anchor = xegpu.convert_layout %broadcast
<{
- input_layout = #xegpu.layout<sg_layout = [4, 2, 6, 1], sg_data = [1, 1, 1, 32]>,
target_layout = #xegpu.layout<sg_layout = [4, 2, 6, 1], sg_data = [1, 1, 1, 32]>
}> : vector<4x2x6x32xindex>
gpu.return
@@ -585,7 +572,6 @@ gpu.module @test_distribution {
: vector<256x32xf32> to vector<32x256xf32>
%anchor = xegpu.convert_layout %trans
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 64], lane_layout = [1, 16], lane_data = [1, 1]>
}> : vector<32x256xf32>
gpu.return
@@ -606,7 +592,6 @@ gpu.module @test_distribution {
%cst = arith.constant dense<[[0], [16], [32], [48], [64], [80], [96], [112], [128], [144], [160], [176], [192], [208], [224], [240], [256], [272], [288], [304], [320], [336], [352], [368], [384], [400], [416], [432], [448], [464], [480], [496]]> : vector<32x1xindex>
%anchor = xegpu.convert_layout %cst
<{
- input_layout = #xegpu.layout<sg_layout = [32, 1], sg_data = [1, 1]>,
target_layout = #xegpu.layout<sg_layout = [32, 1], sg_data = [1, 1]>
}> : vector<32x1xindex>
gpu.return
@@ -641,7 +626,6 @@ gpu.module @test_distribution {
]> : vector<8x8xindex>
%anchor = xegpu.convert_layout %cst_8x8
<{
- input_layout = #xegpu.layout<sg_layout = [4, 4], sg_data = [2, 2]>,
target_layout = #xegpu.layout<sg_layout = [4, 4], sg_data = [2, 2]>
}> : vector<8x8xindex>
gpu.return
@@ -660,14 +644,12 @@ gpu.module @test_distribution {
%cst = arith.constant dense<[0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256, 272, 288, 304, 320, 336, 352, 368, 384, 400, 416, 432, 448, 464, 480, 496]> : vector<32xindex>
%anchor = xegpu.convert_layout %cst
<{
- input_layout = #xegpu.layout<sg_layout = [32], sg_data = [1]>,
target_layout = #xegpu.layout<sg_layout = [32], sg_data = [1]>
}> : vector<32xindex>
// CHECK: arith.constant dense<{{\[}}{{\[}}0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15{{\]}}{{\]}}> : vector<1x16xindex>
%cst_1 = arith.constant dense<[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]> : vector<1x16xindex>
%anchor_1 = xegpu.convert_layout %cst_1
<{
- input_layout = #xegpu.layout<sg_layout = [32, 1], sg_data = [1, 16]>,
target_layout = #xegpu.layout<sg_layout = [32, 1], sg_data = [1, 16]>
}> : vector<1x16xindex>
gpu.return
@@ -679,7 +661,6 @@ gpu.module @test_distribution {
%broadcast = vector.broadcast %arg0 : index to vector<4x1x1xindex>
%anchor = xegpu.convert_layout %broadcast
<{
- input_layout = #xegpu.layout<sg_layout = [4, 8, 1], sg_data = [1, 1, 1]>,
target_layout = #xegpu.layout<sg_layout = [4, 8, 1], sg_data = [1, 1, 1]>
}> : vector<4x1x1xindex>
gpu.return
@@ -698,7 +679,6 @@ gpu.module @test_distribution {
%constant_mask = vector.constant_mask [8] : vector<32xi1>
%anchor = xegpu.convert_layout %constant_mask
<{
- input_layout = #xegpu.layout<sg_layout = [2], sg_data = [16]>,
target_layout = #xegpu.layout<sg_layout = [2], sg_data = [16]>
}> : vector<32xi1>
gpu.return
@@ -724,7 +704,6 @@ gpu.module @test_distribution {
%constant_mask = vector.constant_mask [16, 16] : vector<256x128xi1>
%anchor = xegpu.convert_layout %constant_mask
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>
}> : vector<256x128xi1>
gpu.return
@@ -744,7 +723,6 @@ gpu.module @test_distribution {
%constant_mask = vector.create_mask %cst8 : vector<32xi1>
%anchor = xegpu.convert_layout %constant_mask
<{
- input_layout = #xegpu.layout<sg_layout = [2], sg_data = [16]>,
target_layout = #xegpu.layout<sg_layout = [2], sg_data = [16]>
}> : vector<32xi1>
gpu.return
@@ -771,7 +749,6 @@ gpu.module @test_distribution {
%constant_mask = vector.create_mask %cst16, %cst16 : vector<256x128xi1>
%anchor = xegpu.convert_layout %constant_mask
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>
}> : vector<256x128xi1>
gpu.return
@@ -791,7 +768,6 @@ gpu.module @test_distribution {
%4 = vector.broadcast %3 : vector<256xf32> to vector<256x256xf32>
%anchor = xegpu.convert_layout %4
<{
- input_layout = #xegpu.layout<sg_layout = [8, 8], sg_data = [32, 32], inst_data = [8, 16]>,
target_layout = #xegpu.layout<sg_layout = [8, 8], sg_data = [32, 32], inst_data = [8, 16]>
}> : vector<256x256xf32>
gpu.return
@@ -824,7 +800,6 @@ gpu.module @test_distribution {
%15 = vector.multi_reduction <add>, %14, %cst_3 [1] : vector<1x32x32xf32> to vector<1x32xf32>
%anchor = xegpu.convert_layout %15
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [1, 32, 1], sg_data = [1, 1, 32]>, dims = [1]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [1, 32, 1], sg_data = [1, 1, 32]>, dims = [1]>
}> : vector<1x32xf32>
gpu.return
@@ -866,7 +841,6 @@ gpu.module @test_distribution {
: vector<256x128xf32> to vector<128xf32>
%anchor = xegpu.convert_layout %reduce
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>, dims = [0]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>, dims = [0]>
}> : vector<128xf32>
gpu.return
@@ -899,7 +873,6 @@ gpu.module @test_distribution {
%reduce = vector.multi_reduction <add>, %load, %cst [2, 3] : vector<2x2x128x128xf32> to vector<2x2xf32>
%anchor = xegpu.convert_layout %reduce
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [2, 2, 4, 4], sg_data = [1, 1, 32, 32]>, dims = [2, 3]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [2, 2, 4, 4], sg_data = [1, 1, 32, 32]>, dims = [2, 3]>
}> : vector<2x2xf32>
gpu.return
@@ -932,7 +905,6 @@ gpu.module @test_distribution {
%reduce = vector.multi_reduction <add>, %load, %cst [2, 3] : vector<32x32x128x128xf32> to vector<32x32xf32>
%anchor = xegpu.convert_layout %reduce
<{
- input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [2, 2, 4, 4], sg_data = [16, 16, 32, 32]>, dims = [2, 3]>,
target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [2, 2, 4, 4], sg_data = [16, 16, 32, 32]>, dims = [2, 3]>
}> : vector<32x32xf32>
gpu.return
@@ -1017,7 +989,6 @@ gpu.module @test_distribution {
target_layout = #xegpu.layout<sg_layout = [8, 8], sg_data = [16, 32], inst_data = [16, 16]>}> : vector<128x256xf32>
%anchor = xegpu.convert_layout %2
<{
- input_layout = #xegpu.layout<sg_layout = [8, 8], sg_data = [16, 32], inst_data = [16, 16]>,
target_layout = #xegpu.layout<sg_layout = [8, 8], sg_data = [16, 32], inst_data = [16, 16]>
}> : vector<128x256xf32>
gpu.return
@@ -1060,7 +1031,6 @@ gpu.module @test_distribution {
target_layout = #xegpu.layout<sg_layout = [8, 8, 8], sg_data = [1, 16, 32], inst_data = [1, 16, 16]>}> : vector<8x128x256xf32>
%anchor = xegpu.convert_layout %2
<{
- input_layout = #xegpu.layout<sg_layout = [8, 8, 8], sg_data = [1, 16, 32], inst_data = [1, 16, 16]>,
target_layout = #xegpu.layout<sg_layout = [8, 8, 8], sg_data = [1, 16, 32], inst_data = [1, 16, 16]>
}> : vector<8x128x256xf32>
gpu.return
@@ -1076,7 +1046,7 @@ gpu.module @test_distribution {
%11 = xegpu.load %10[%offset], %mask <{layout = #xegpu.layout<sg_layout = [32, 1], sg_data = [1, 32]>}> : i64, vector<32x32xindex>, vector<32x32xi1> -> vector<32x32xf32>
%12 = vector.multi_reduction <add>, %11, %cst_0 [0, 1] : vector<32x32xf32> to f32
// CHECK-NOT: xegpu.convert_layout
- %13 = xegpu.convert_layout %12 <{input_layout = #xegpu.slice<#xegpu.layout<sg_layout = [32, 1], sg_data = [1, 32]>, dims = [0, 1]>, target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [32, 1], sg_data = [1, 32]>, dims = [0, 1]>}> : f32
+ %13 = xegpu.convert_layout %12 <{target_layout = #xegpu.slice<#xegpu.layout<sg_layout = [32, 1], sg_data = [1, 32]>, dims = [0, 1]>}> : f32
gpu.return
}
@@ -1111,7 +1081,6 @@ gpu.module @test_distribution {
%bcast2 = vector.broadcast %scast2 : vector<256x16x1x256x16x16xf32> to vector<256x16x16x256x16x16xf32>
%anchor = xegpu.convert_layout %bcast2
<{
- input_layout = #xegpu.layout<sg_layout = [8, 1, 1, 8, 1, 1], sg_data = [32, 16, 16, 32, 16, 16]>,
target_layout = #xegpu.layout<sg_layout = [8, 1, 1, 8, 1, 1], sg_data = [32, 16, 16, 32, 16, 16]>
}> : vector<256x16x16x256x16x16xf32>
gpu.return
@@ -1296,7 +1265,6 @@ gpu.module @test_distribution {
%cst = arith.constant dense<1.0> : vector<256x128xf32>
%anchor = xegpu.convert_layout %cst
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>
}> : vector<256x128xf32>
gpu.return
@@ -1340,7 +1308,6 @@ gpu.module @test_distribution {
%bitcast2 = vector.bitcast %add : vector<256x256xi16> to vector<256x128xi32>
%anchor = xegpu.convert_layout %bitcast2
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>
}> : vector<256x128xi32>
gpu.return
@@ -1361,7 +1328,6 @@ gpu.module @test_distribution {
: vector<256x128xf32> -> vector<256x256xf32>
%anchor = xegpu.convert_layout %interleave
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 64]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 64]>
}> : vector<256x256xf32>
gpu.return
@@ -1375,7 +1341,6 @@ gpu.module @test_distribution {
%deinterleave:2 = vector.deinterleave %load : vector<256x256xf32> -> vector<256x128xf32>
%anchor = xegpu.convert_layout %deinterleave#0
<{
- input_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>,
target_layout = #xegpu.layout<sg_layout = [8, 4], sg_data = [32, 32]>
}> : vector<256x128xf32>
gpu.return
More information about the Mlir-commits
mailing list