mlir.dialects._vector_transform_ops_gen

Attributes

_ods_ir
_Buffer

Classes

ApplyCastAwayVectorLeadingOneDimPatternsOp	Collect a set of leading one dimension removal patterns.
ApplyCastAwayVectorLeadingOneDimPatternsOpAdaptor
ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp	Apply vector patterns to drop the inner most unit dims from
ApplyDropInnerMostUnitDimsFromXferOpsPatternsOpAdaptor
ApplyDropUnitDimWithShapeCastPatternsOp	Apply vector patterns to fold unit dims with vector.shape_cast Ops:
ApplyDropUnitDimWithShapeCastPatternsOpAdaptor
ApplyFlattenVectorTransferOpsPatternsOp	Collect patterns to rewrite contiguous row-major vector.transfer_read or
ApplyFlattenVectorTransferOpsPatternsOpAdaptor
ApplyFoldArithExtensionPatternsOp	Collect a set of patterns that fold arithmetic extension on floating point
ApplyFoldArithExtensionPatternsOpAdaptor
ApplyFoldElementwiseToVectorPatternsOp	Collect a set of patterns that fold elementwise op on vectors to the vector
ApplyFoldElementwiseToVectorPatternsOpAdaptor
ApplyInterleaveAndDeinterleaveToShufflePatternsOp	Indicates that 1D vector interleave and deinterleave operations should be
ApplyInterleaveAndDeinterleaveToShufflePatternsOpAdaptor
ApplyLowerBitCastPatternsOp	Indicates that vector bitcast operations should be lowered to
ApplyLowerBitCastPatternsOpAdaptor
ApplyLowerBroadcastPatternsOp	Indicates that vector broadcast operations should be lowered to
ApplyLowerBroadcastPatternsOpAdaptor
ApplyLowerContractionPatternsOp	Indicates that vector contraction-like operations should be lowered to
ApplyLowerContractionPatternsOpAdaptor
ApplyLowerCreateMaskPatternsOp	Indicates that vector create_mask-like operations should be lowered to
ApplyLowerCreateMaskPatternsOpAdaptor
ApplyLowerGatherPatternsOp	Indicates that vector.gather operations should be lowered to
ApplyLowerGatherPatternsOpAdaptor
ApplyLowerInterleavePatternsOp	Indicates that vector interleave operations should be lowered to
ApplyLowerInterleavePatternsOpAdaptor
ApplyLowerMaskedTransfersPatternsOp	Apply opt-in patterns that lower vector.mask operations surrounding
ApplyLowerMaskedTransfersPatternsOpAdaptor
ApplyLowerMasksPatternsOp	Indicates that vector.create_mask and vector.constant_mask operations
ApplyLowerMasksPatternsOpAdaptor
ApplyLowerOuterProductPatternsOp	Indicates that the vector outerproduct operations should be lowered to
ApplyLowerOuterProductPatternsOpAdaptor
ApplyLowerScanPatternsOp	Indicates that vector.scan operations should be lowered to
ApplyLowerScanPatternsOpAdaptor
ApplyLowerShapeCastPatternsOp	Indicates that vector shape_cast operations should be lowered to
ApplyLowerShapeCastPatternsOpAdaptor
ApplyLowerStepPatternsOp	Indicates that vector.step operations should be lowered to finer-grained
ApplyLowerStepPatternsOpAdaptor
ApplyLowerTransferPatternsOp	Indicates that vector transfer operations should be lowered to finer-grained
ApplyLowerTransferPatternsOpAdaptor
ApplyLowerTransposePatternsOp	Indicates that vector transpose-like operations should be lowered to
ApplyLowerTransposePatternsOpAdaptor
ApplyMaterializeMasksPatternsOp	Indicates that mask operations should be lowered to fine-grained arithemtic
ApplyMaterializeMasksPatternsOpAdaptor
ApplyMultiReductionFlatteningPatternsOp	Indicates that vector multi_reduction operations should be flattened from
ApplyMultiReductionFlatteningPatternsOpAdaptor
ApplyMultiReductionUnrollingPatternsOp	Indicates that vector multi_reduction operations should be unrolled.
ApplyMultiReductionUnrollingPatternsOpAdaptor
ApplyRankReducingSubviewPatternsOp	Apply opt-in vector transfer permutation patterns that include:
ApplyRankReducingSubviewPatternsOpAdaptor
ApplyReorderMultiReductionPatternsOp	Indicates that vector multi_reduction-like operations should be
ApplyReorderMultiReductionPatternsOpAdaptor
ApplyRewriteNarrowTypePatternsOp	Indicates that vector narrow rewrite operations should be applied.
ApplyRewriteNarrowTypePatternsOpAdaptor
ApplySinkVectorMemPatternsOp	Patterns that replace redundant Vector Ops (followed by
ApplySinkVectorMemPatternsOpAdaptor
ApplySinkVectorPatternsOp	Patterns that remove redundant Vector Ops by re-ordering them with
ApplySinkVectorPatternsOpAdaptor
ApplySplitTransferFullPartialPatternsOp	Indicates that vector transfer operations should be split to full and
ApplySplitTransferFullPartialPatternsOpAdaptor
ApplyTransferPermutationPatternsOp	Apply opt-in vector transfer permutation patterns that include:
ApplyTransferPermutationPatternsOpAdaptor
ApplyTransferToScfPatternsOp	Indicates that vector transfer operations should be rewritten with scf.for
ApplyTransferToScfPatternsOpAdaptor
ApplyUnrollContractPatternsOp	Apply unroll patterns for vector.contract using the given shapes as the
ApplyUnrollContractPatternsOpAdaptor
ApplyUnrollFromElementsPatternsOp	Indicates that vector from_elements operations should be unrolled
ApplyUnrollFromElementsPatternsOpAdaptor
ApplyUnrollToElementsPatternsOp	Indicates that vector to_elements operations should be unrolled
ApplyUnrollToElementsPatternsOpAdaptor
ApplyVectorLinearizeConversionPatternsOp	Collects patterns for ND vector (n >= 2) vector linearization.
ApplyVectorLinearizeConversionPatternsOpAdaptor
ApplyVectorReductionToContractPatternsOp	Apply opt-in patterns that convert reductions to contract:
ApplyVectorReductionToContractPatternsOpAdaptor
ApplyVectorToLLVMConversionPatternsOp	Collects patterns that convert vector dialect ops to LLVM dialect ops. These
ApplyVectorToLLVMConversionPatternsOpAdaptor
VectorLinearizeTypeConverterOp	Builds a type converter that controls which ND (n >= 2) vector types are
VectorLinearizeTypeConverterOpAdaptor

Functions

apply_patterns_vector_cast_away_vector_leading_one_dim(...)
apply_patterns_vector_drop_inner_most_unit_dims_from_xfer_ops(...)
apply_patterns_vector_drop_unit_dims_with_shape_cast(...)
apply_patterns_vector_flatten_vector_transfer_ops(...)
apply_patterns_vector_fold_arith_extension(...)
apply_patterns_vector_elementwise_to_vector(...)
apply_patterns_vector_interleave_and_deinterleave_to_shuffle(...)
apply_patterns_vector_lower_bitcast(...)
apply_patterns_vector_lower_broadcast(...)
apply_patterns_vector_lower_contraction(...)
apply_patterns_vector_lower_create_mask(...)
apply_patterns_vector_lower_gather(...)
apply_patterns_vector_lower_interleave(...)
apply_patterns_vector_lower_masked_transfers(...)
apply_patterns_vector_lower_masks(...)
apply_patterns_vector_lower_outerproduct(...)
apply_patterns_vector_lower_scan(...)
apply_patterns_vector_lower_shape_cast(...)
apply_patterns_vector_lower_step(...)
apply_patterns_vector_lower_transfer(...)
apply_patterns_vector_lower_transpose(...)
apply_patterns_vector_materialize_masks(...)
apply_patterns_vector_multi_reduction_flattening(...)
apply_patterns_vector_multi_reduction_unrolling(...)
apply_patterns_vector_rank_reducing_subview_patterns(...)
apply_patterns_vector_reorder_multi_reduction_dims(...)
apply_patterns_vector_rewrite_narrow_types(...)
apply_patterns_vector_sink_mem_ops(...)
apply_patterns_vector_sink_ops(→ ApplySinkVectorPatternsOp)
apply_patterns_vector_split_transfer_full_partial(...)
apply_patterns_vector_transfer_permutation_patterns(...)
apply_patterns_vector_transfer_to_scf(...)
apply_patterns_vector_unroll_contract(...)
apply_patterns_vector_unroll_from_elements(...)
apply_patterns_vector_unroll_to_elements(...)
apply_conversion_patterns_vector_linearize(...)
apply_patterns_vector_reduction_to_contract(...)
apply_conversion_patterns_vector_vector_to_llvm(...)
apply_conversion_patterns_vector_linearize_type_converter(...)

Module Contents

mlir.dialects._vector_transform_ops_gen._ods_ir

mlir.dialects._vector_transform_ops_gen._Buffer

class mlir.dialects._vector_transform_ops_gen.ApplyCastAwayVectorLeadingOneDimPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Collect a set of leading one dimension removal patterns.

These patterns insert vector.shape_cast to remove leading one dimensions to expose more canonical forms of read/write/insert/extract operations. With them, there are more chances that we can cancel out extract-insert pairs or forward write-read pairs.

OPERATION_NAME = 'transform.apply_patterns.vector.cast_away_vector_leading_one_dim'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyCastAwayVectorLeadingOneDimPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.cast_away_vector_leading_one_dim'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_cast_away_vector_leading_one_dim(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyCastAwayVectorLeadingOneDimPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Apply vector patterns to drop the inner most unit dims from vector.transfer_read and vector.transfer_write Ops by taking a subview (via memref.subview) of the original source/destination MemRef. Since it requires the input/ouptu to be MemRefs, this Op is only helpful past-bufferization.

OPERATION_NAME = 'transform.apply_patterns.vector.drop_inner_most_unit_dims_from_xfer_ops'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyDropInnerMostUnitDimsFromXferOpsPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.drop_inner_most_unit_dims_from_xfer_ops'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_drop_inner_most_unit_dims_from_xfer_ops(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyDropUnitDimWithShapeCastPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Apply vector patterns to fold unit dims with vector.shape_cast Ops:

• DropUnitDimFromElementwiseOps

• DropUnitDimsFromScfForOp

• DropUnitDimsFromTransposeOp

Excludes patterns for vector.transfer Ops. This is complemented by shape_cast folding patterns.

OPERATION_NAME = 'transform.apply_patterns.vector.drop_unit_dims_with_shape_cast'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyDropUnitDimWithShapeCastPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.drop_unit_dims_with_shape_cast'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_drop_unit_dims_with_shape_cast(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyDropUnitDimWithShapeCastPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyFlattenVectorTransferOpsPatternsOp(*, target_vector_bitwidth: int | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Collect patterns to rewrite contiguous row-major vector.transfer_read or vector.transfer_write operations to a 1D operation.

OPERATION_NAME = 'transform.apply_patterns.vector.flatten_vector_transfer_ops'

_ODS_REGIONS = (0, True)

target_vector_bitwidth() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyFlattenVectorTransferOpsPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.flatten_vector_transfer_ops'

target_vector_bitwidth() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_flatten_vector_transfer_ops(*, target_vector_bitwidth: int | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyFlattenVectorTransferOpsPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyFoldArithExtensionPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Collect a set of patterns that fold arithmetic extension on floating point into vector contract for the backends with native support.

OPERATION_NAME = 'transform.apply_patterns.vector.fold_arith_extension'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyFoldArithExtensionPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.fold_arith_extension'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_fold_arith_extension(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyFoldArithExtensionPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyFoldElementwiseToVectorPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Collect a set of patterns that fold elementwise op on vectors to the vector dialect.

OPERATION_NAME = 'transform.apply_patterns.vector.elementwise_to_vector'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyFoldElementwiseToVectorPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.elementwise_to_vector'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_elementwise_to_vector(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyFoldElementwiseToVectorPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyInterleaveAndDeinterleaveToShufflePatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that 1D vector interleave and deinterleave operations should be rewritten as vector shuffle operations.

This is motivated by some current codegen backends not handling vector interleave and deinterleave operations.

OPERATION_NAME = 'transform.apply_patterns.vector.interleave_and_deinterleave_to_shuffle'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyInterleaveAndDeinterleaveToShufflePatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.interleave_and_deinterleave_to_shuffle'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_interleave_and_deinterleave_to_shuffle(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyInterleaveAndDeinterleaveToShufflePatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerBitCastPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector bitcast operations should be lowered to finer-grained vector primitives.

This is usally a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_bitcast'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerBitCastPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_bitcast'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_bitcast(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerBitCastPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerBroadcastPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector broadcast operations should be lowered to finer-grained vector primitives.

This is usally a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_broadcast'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerBroadcastPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_broadcast'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_broadcast(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerBroadcastPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerContractionPatternsOp(*, lowering_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector contraction-like operations should be lowered to finer-grained vector primitives.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_contraction'

_ODS_REGIONS = (0, True)

lowering_strategy() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyLowerContractionPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_contraction'

lowering_strategy() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_contraction(*, lowering_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerContractionPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerCreateMaskPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector create_mask-like operations should be lowered to finer-grained vector primitives.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_create_mask'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerCreateMaskPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_create_mask'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_create_mask(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerCreateMaskPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerGatherPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector.gather operations should be lowered to finer-grained vector primitives.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_gather'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerGatherPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_gather'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_gather(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerGatherPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerInterleavePatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector interleave operations should be lowered to finer-grained vector primitives.

This is usally a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_interleave'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerInterleavePatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_interleave'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_interleave(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerInterleavePatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerMaskedTransfersPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Apply opt-in patterns that lower vector.mask operations surrounding side-effecting ops:

• MaskedTransferReadOpPattern

• MaskedTransferWriteOpPattern

• MaskedGatherOpPattern

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_masked_transfers'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerMaskedTransfersPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_masked_transfers'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_masked_transfers(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerMaskedTransfersPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerMasksPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector.create_mask and vector.constant_mask operations should be lowered to finer-grained vector primitives.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_masks'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerMasksPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_masks'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_masks(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerMasksPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerOuterProductPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that the vector outerproduct operations should be lowered to finer-grained vector primitives.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_outerproduct'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerOuterProductPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_outerproduct'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_outerproduct(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerOuterProductPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerScanPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector.scan operations should be lowered to finer-grained vector primitives.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_scan'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerScanPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_scan'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_scan(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerScanPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerShapeCastPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector shape_cast operations should be lowered to finer-grained vector primitives.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_shape_cast'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyLowerShapeCastPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_shape_cast'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_shape_cast(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerShapeCastPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerStepPatternsOp(index_bitwidth: int | _ods_ir, *, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector.step operations should be lowered to finer-grained vector primitives.

index_bitwidth is the bitwidth used to materialize index-typed steps; a bitwidth of 0 leaves them untouched (e.g. to defer to a later, target-aware lowering). It must not exceed the index storage bitwidth. Integer-typed steps are unaffected by this option.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_step'

_ODS_REGIONS = (0, True)

index_bitwidth() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyLowerStepPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_step'

index_bitwidth() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_step(index_bitwidth: int | _ods_ir, *, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerStepPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerTransferPatternsOp(*, max_transfer_rank: int | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector transfer operations should be lowered to finer-grained vector primitives.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_transfer'

_ODS_REGIONS = (0, True)

max_transfer_rank() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyLowerTransferPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_transfer'

max_transfer_rank() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_transfer(*, max_transfer_rank: int | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerTransferPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyLowerTransposePatternsOp(*, lowering_strategy: Any | _ods_ir | None = None, avx2_lowering_strategy: bool | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector transpose-like operations should be lowered to finer-grained vector primitives.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.lower_transpose'

_ODS_REGIONS = (0, True)

lowering_strategy() → _ods_ir

avx2_lowering_strategy() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyLowerTransposePatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.lower_transpose'

lowering_strategy() → _ods_ir

avx2_lowering_strategy() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_transpose(*, lowering_strategy: Any | _ods_ir | None = None, avx2_lowering_strategy: bool | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyLowerTransposePatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyMaterializeMasksPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that mask operations should be lowered to fine-grained arithemtic operations.

This is usually the last step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.materialize_masks'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyMaterializeMasksPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.materialize_masks'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_materialize_masks(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyMaterializeMasksPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyMultiReductionFlatteningPatternsOp(*, lowering_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector multi_reduction operations should be flattened from more than 2-D to 2-D.

OPERATION_NAME = 'transform.apply_patterns.vector.multi_reduction_flattening'

_ODS_REGIONS = (0, True)

lowering_strategy() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyMultiReductionFlatteningPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.multi_reduction_flattening'

lowering_strategy() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_multi_reduction_flattening(*, lowering_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyMultiReductionFlatteningPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyMultiReductionUnrollingPatternsOp(*, lowering_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector multi_reduction operations should be unrolled. 1-D multi_reductions are converted directly to vector.reduction. 2-D multi_reductions are unrolled into either a sequence of vector.reduction ops (innerreduction) or element-wise arith ops (innerparallel).

This populates the patterns from populateVectorMultiReductionUnrollingPatterns, i.e.:

• OneDimMultiReductionToReduction

• TwoDimMultiReductionToReduction (innerreduction)

• TwoDimMultiReductionToElementWise (innerparallel)

OPERATION_NAME = 'transform.apply_patterns.vector.multi_reduction_unrolling'

_ODS_REGIONS = (0, True)

lowering_strategy() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyMultiReductionUnrollingPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.multi_reduction_unrolling'

lowering_strategy() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_multi_reduction_unrolling(*, lowering_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyMultiReductionUnrollingPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyRankReducingSubviewPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Apply opt-in vector transfer permutation patterns that include:

• TransferReadDropUnitDimsPattern

• TransferWriteDropUnitDimsPattern

These patterns have the effect of rewriting a vector.transfer with unit dimensions into a rank-reduced version thanks to subview operations. This is complemented by shape_cast folding patterns.

OPERATION_NAME = 'transform.apply_patterns.vector.rank_reducing_subview_patterns'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyRankReducingSubviewPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.rank_reducing_subview_patterns'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_rank_reducing_subview_patterns(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyRankReducingSubviewPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyReorderMultiReductionPatternsOp(*, lowering_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector multi_reduction-like operations should be transformed such that all reduction dimensions become innermost or outermost, depending on lowering_strategy.

This populates the patterns from populateVectorMultiReductionReorderPatterns, i.e.:

• InnerOuterDimReductionConversion

OPERATION_NAME = 'transform.apply_patterns.vector.reorder_multi_reduction_dims'

_ODS_REGIONS = (0, True)

lowering_strategy() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyReorderMultiReductionPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.reorder_multi_reduction_dims'

lowering_strategy() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_reorder_multi_reduction_dims(*, lowering_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyReorderMultiReductionPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyRewriteNarrowTypePatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector narrow rewrite operations should be applied.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

Warning: these patterns currently only work for little endian targets.

OPERATION_NAME = 'transform.apply_patterns.vector.rewrite_narrow_types'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyRewriteNarrowTypePatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.rewrite_narrow_types'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_rewrite_narrow_types(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyRewriteNarrowTypePatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplySinkVectorMemPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Patterns that replace redundant Vector Ops (followed by vector.load/vector.store) with either vector.load/vector.store or memref.load/memref.store. Currently limited to 1-element vectors.

Example:

vector.load %arg0[%arg1] : memref<?xf32>, vector<4xf32>
vector.extract %0[1] : f32 from vector<4xf32>

Gets converted to:

%c1 = arith.constant 1 : index
%0 = arith.addi %arg1, %c1 overflow<nsw> : index
%1 = memref.load %arg0[%0] : memref<?xf32>

OPERATION_NAME = 'transform.apply_patterns.vector.sink_mem_ops'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplySinkVectorMemPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.sink_mem_ops'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_sink_mem_ops(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplySinkVectorMemPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplySinkVectorPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Patterns that remove redundant Vector Ops by re-ordering them with e.g. elementwise Ops.

Example:

%at = vector.transpose %a, [1, 0]: vector<4x2xf32> to vector<2x4xf32>
%bt = vector.transpose %b, [1, 0]: vector<4x2xf32> to vector<2x4xf32>
%r = arith.addf %at, %bt : vector<2x4xf32>

gets converted to:

%0 = arith.addf %a, %b : vector<4x2xf32>
%r = vector.transpose %0, [1, 0] : vector<2x4xf32>

At the moment, these patterns are limited to vector.broadcast, vector.transpose and vector.extract.

OPERATION_NAME = 'transform.apply_patterns.vector.sink_ops'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplySinkVectorPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.sink_ops'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_sink_ops(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplySinkVectorPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplySplitTransferFullPartialPatternsOp(*, split_transfer_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector transfer operations should be split to full and partial parts.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.split_transfer_full_partial'

_ODS_REGIONS = (0, True)

split_transfer_strategy() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplySplitTransferFullPartialPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.split_transfer_full_partial'

split_transfer_strategy() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_split_transfer_full_partial(*, split_transfer_strategy: Any | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplySplitTransferFullPartialPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyTransferPermutationPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Apply opt-in vector transfer permutation patterns that include:

• TransferReadPermutationLowering

• TransferWritePermutationLowering

• TransferOpReduceRank

• TransferWriteNonPermutationLowering

These patterns have the effect of rewriting a vector.transfer with an arbitrary permutation_map to a vector.transfer with a permutation_map that is a minor identity followed by a vector.transpose.

In other words, this makes the vector.transfer contiguous on the most minor dimensions and materializes the permutation_map as a vector.transpose.

OPERATION_NAME = 'transform.apply_patterns.vector.transfer_permutation_patterns'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyTransferPermutationPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.transfer_permutation_patterns'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_transfer_permutation_patterns(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyTransferPermutationPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyTransferToScfPatternsOp(*, max_transfer_rank: int | _ods_ir | None = None, full_unroll: bool | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector transfer operations should be rewritten with scf.for loops over finer-grained vector primitives.

This is usually a late step that is run after bufferization as part of the process of lowering to e.g. LLVM or NVVM.

OPERATION_NAME = 'transform.apply_patterns.vector.transfer_to_scf'

_ODS_REGIONS = (0, True)

max_transfer_rank() → _ods_ir

full_unroll() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyTransferToScfPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.transfer_to_scf'

max_transfer_rank() → _ods_ir

full_unroll() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_transfer_to_scf(*, max_transfer_rank: int | _ods_ir | None = None, full_unroll: bool | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyTransferToScfPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyUnrollContractPatternsOp(m: int | _ods_ir, n: int | _ods_ir, k: int | _ods_ir, *, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Apply unroll patterns for vector.contract using the given shapes as the target shape. If no vector.contract Op is present in the target block, no unrolling takes place.

This op assumes that the target vector.contract Op models a matrix multiplication. Generalising this Op to other cases is left as a TODO.

OPERATION_NAME = 'transform.apply_patterns.vector.unroll_contract'

_ODS_REGIONS = (0, True)

m() → _ods_ir

n() → _ods_ir

k() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyUnrollContractPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.unroll_contract'

m() → _ods_ir

n() → _ods_ir

k() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_unroll_contract(m: int | _ods_ir, n: int | _ods_ir, k: int | _ods_ir, *, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyUnrollContractPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyUnrollFromElementsPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector from_elements operations should be unrolled along the outermost dimension.

OPERATION_NAME = 'transform.apply_patterns.vector.unroll_from_elements'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyUnrollFromElementsPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.unroll_from_elements'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_unroll_from_elements(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyUnrollFromElementsPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyUnrollToElementsPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Indicates that vector to_elements operations should be unrolled along the outermost dimension.

OPERATION_NAME = 'transform.apply_patterns.vector.unroll_to_elements'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyUnrollToElementsPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.unroll_to_elements'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_unroll_to_elements(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyUnrollToElementsPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyVectorLinearizeConversionPatternsOp(*, shuffle_like_ops: bool | _ods_ir | None = None, target_vector_bitwidth: int | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Collects patterns for ND vector (n >= 2) vector linearization.

These patterns require the type converter built by the corresponding linearize type converter op.

The patterns can be customized as follows:

• shuffle_like_ops: Linearizes ND vector ops into 1D vector shuffles.

• target_vector_bitwidth: If set, ops whose inner-most vector dimension

is at least this many bits wide are not linearized.

OPERATION_NAME = 'transform.apply_conversion_patterns.vector.linearize'

_ODS_REGIONS = (0, True)

shuffle_like_ops() → _ods_ir

target_vector_bitwidth() → _ods_ir | None

class mlir.dialects._vector_transform_ops_gen.ApplyVectorLinearizeConversionPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_conversion_patterns.vector.linearize'

shuffle_like_ops() → _ods_ir

target_vector_bitwidth() → _ods_ir | None

mlir.dialects._vector_transform_ops_gen.apply_conversion_patterns_vector_linearize(*, shuffle_like_ops: bool | _ods_ir | None = None, target_vector_bitwidth: int | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyVectorLinearizeConversionPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyVectorReductionToContractPatternsOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Apply opt-in patterns that convert reductions to contract:

• MultiReduceToContract

• CombineContractBroadcast

• CombineContractABTranspose

• CombineContractResultTranspose

• ReorderElementwiseOpsOnTranspose

• ReorderElementwiseOpsOnBroadcast

• ReorderCastOpsOnBroadcast

These patterns have the effect of rewriting a vector.multi_reduce into a vector.contract.

OPERATION_NAME = 'transform.apply_patterns.vector.reduction_to_contract'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.ApplyVectorReductionToContractPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_patterns.vector.reduction_to_contract'

mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_reduction_to_contract(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyVectorReductionToContractPatternsOp

class mlir.dialects._vector_transform_ops_gen.ApplyVectorToLLVMConversionPatternsOp(*, reassociate_fp_reductions: bool | _ods_ir | None = None, force_32bit_vector_indices: bool | _ods_ir | None = None, use_vector_alignment: bool | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Collects patterns that convert vector dialect ops to LLVM dialect ops. These patterns require an “LLVMTypeConverter”.

The patterns can be customized as follows:

• reassociate_fp_reductions: Allows LLVM to reassociate floating-point

reductions for speed. * force_32bit_vector_indices: Allows the compiler to assume that vector indices fit in 32-bit if that yields faster code.

OPERATION_NAME = 'transform.apply_conversion_patterns.vector.vector_to_llvm'

_ODS_REGIONS = (0, True)

reassociate_fp_reductions() → _ods_ir

force_32bit_vector_indices() → _ods_ir

use_vector_alignment() → _ods_ir

class mlir.dialects._vector_transform_ops_gen.ApplyVectorToLLVMConversionPatternsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_conversion_patterns.vector.vector_to_llvm'

reassociate_fp_reductions() → _ods_ir

force_32bit_vector_indices() → _ods_ir

use_vector_alignment() → _ods_ir

mlir.dialects._vector_transform_ops_gen.apply_conversion_patterns_vector_vector_to_llvm(*, reassociate_fp_reductions: bool | _ods_ir | None = None, force_32bit_vector_indices: bool | _ods_ir | None = None, use_vector_alignment: bool | _ods_ir | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → ApplyVectorToLLVMConversionPatternsOp

class mlir.dialects._vector_transform_ops_gen.VectorLinearizeTypeConverterOp(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Builds a type converter that controls which ND (n >= 2) vector types are linearized into 1D forms, and materializes conversions.

OPERATION_NAME = 'transform.apply_conversion_patterns.vector.linearize_type_converter'

_ODS_REGIONS = (0, True)

class mlir.dialects._vector_transform_ops_gen.VectorLinearizeTypeConverterOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'transform.apply_conversion_patterns.vector.linearize_type_converter'

mlir.dialects._vector_transform_ops_gen.apply_conversion_patterns_vector_linearize_type_converter(*, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → VectorLinearizeTypeConverterOp