mlir.dialects._vector_transform_ops_gen ======================================= .. py:module:: mlir.dialects._vector_transform_ops_gen Attributes ---------- .. autoapisummary:: mlir.dialects._vector_transform_ops_gen._ods_ir mlir.dialects._vector_transform_ops_gen._Buffer Classes ------- .. autoapisummary:: mlir.dialects._vector_transform_ops_gen.ApplyCastAwayVectorLeadingOneDimPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyCastAwayVectorLeadingOneDimPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyDropInnerMostUnitDimsFromXferOpsPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyDropUnitDimWithShapeCastPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyDropUnitDimWithShapeCastPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyFlattenVectorTransferOpsPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyFlattenVectorTransferOpsPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyFoldArithExtensionPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyFoldArithExtensionPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyFoldElementwiseToVectorPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyFoldElementwiseToVectorPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyInterleaveAndDeinterleaveToShufflePatternsOp mlir.dialects._vector_transform_ops_gen.ApplyInterleaveAndDeinterleaveToShufflePatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerBitCastPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerBitCastPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerBroadcastPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerBroadcastPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerContractionPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerContractionPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerCreateMaskPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerCreateMaskPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerGatherPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerGatherPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerInterleavePatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerInterleavePatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerMaskedTransfersPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerMaskedTransfersPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerMasksPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerMasksPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerOuterProductPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerOuterProductPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerScanPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerScanPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerShapeCastPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerShapeCastPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerStepPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerStepPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerTransferPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerTransferPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyLowerTransposePatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerTransposePatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyMaterializeMasksPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyMaterializeMasksPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyMultiReductionFlatteningPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyMultiReductionFlatteningPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyMultiReductionUnrollingPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyMultiReductionUnrollingPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyRankReducingSubviewPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyRankReducingSubviewPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyReorderMultiReductionPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyReorderMultiReductionPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyRewriteNarrowTypePatternsOp mlir.dialects._vector_transform_ops_gen.ApplyRewriteNarrowTypePatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplySinkVectorMemPatternsOp mlir.dialects._vector_transform_ops_gen.ApplySinkVectorMemPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplySinkVectorPatternsOp mlir.dialects._vector_transform_ops_gen.ApplySinkVectorPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplySplitTransferFullPartialPatternsOp mlir.dialects._vector_transform_ops_gen.ApplySplitTransferFullPartialPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyTransferPermutationPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyTransferPermutationPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyTransferToScfPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyTransferToScfPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyUnrollFromElementsPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyUnrollFromElementsPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyUnrollToElementsPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyUnrollToElementsPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyVectorReductionToContractPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyVectorReductionToContractPatternsOpAdaptor mlir.dialects._vector_transform_ops_gen.ApplyVectorToLLVMConversionPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyVectorToLLVMConversionPatternsOpAdaptor Functions --------- .. autoapisummary:: mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_cast_away_vector_leading_one_dim mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_drop_inner_most_unit_dims_from_xfer_ops mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_drop_unit_dims_with_shape_cast mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_flatten_vector_transfer_ops mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_fold_arith_extension mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_elementwise_to_vector mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_interleave_and_deinterleave_to_shuffle mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_bitcast mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_broadcast mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_contraction mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_create_mask mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_gather mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_interleave mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_masked_transfers mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_masks mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_outerproduct mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_scan mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_shape_cast mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_step mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_transfer mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_lower_transpose mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_materialize_masks mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_multi_reduction_flattening mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_multi_reduction_unrolling mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_rank_reducing_subview_patterns mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_reorder_multi_reduction_dims mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_rewrite_narrow_types mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_sink_mem_ops mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_sink_ops mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_split_transfer_full_partial mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_transfer_permutation_patterns mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_transfer_to_scf mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_unroll_from_elements mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_unroll_to_elements mlir.dialects._vector_transform_ops_gen.apply_patterns_vector_reduction_to_contract mlir.dialects._vector_transform_ops_gen.apply_conversion_patterns_vector_vector_to_llvm Module Contents --------------- .. py:data:: _ods_ir .. py:data:: _Buffer .. py:class:: ApplyCastAwayVectorLeadingOneDimPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.cast_away_vector_leading_one_dim' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyCastAwayVectorLeadingOneDimPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyCastAwayVectorLeadingOneDimPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.cast_away_vector_leading_one_dim' .. py:function:: apply_patterns_vector_cast_away_vector_leading_one_dim(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyCastAwayVectorLeadingOneDimPatternsOp .. py:class:: ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.drop_inner_most_unit_dims_from_xfer_ops' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyDropInnerMostUnitDimsFromXferOpsPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyDropInnerMostUnitDimsFromXferOpsPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.drop_inner_most_unit_dims_from_xfer_ops' .. py:function:: apply_patterns_vector_drop_inner_most_unit_dims_from_xfer_ops(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp .. py:class:: ApplyDropUnitDimWithShapeCastPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.drop_unit_dims_with_shape_cast' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyDropUnitDimWithShapeCastPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyDropUnitDimWithShapeCastPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.drop_unit_dims_with_shape_cast' .. py:function:: apply_patterns_vector_drop_unit_dims_with_shape_cast(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyDropUnitDimWithShapeCastPatternsOp .. py:class:: ApplyFlattenVectorTransferOpsPatternsOp(*, target_vector_bitwidth: Optional[Union[int, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Collect patterns to rewrite contiguous row-major vector.transfer_read or vector.transfer_write operations to a 1D operation. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.flatten_vector_transfer_ops' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: target_vector_bitwidth() -> _ods_ir .. py:class:: ApplyFlattenVectorTransferOpsPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyFlattenVectorTransferOpsPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.flatten_vector_transfer_ops' .. py:method:: target_vector_bitwidth() -> _ods_ir .. py:function:: apply_patterns_vector_flatten_vector_transfer_ops(*, target_vector_bitwidth: Optional[Union[int, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyFlattenVectorTransferOpsPatternsOp .. py:class:: ApplyFoldArithExtensionPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Collect a set of patterns that fold arithmetic extension on floating point into vector contract for the backends with native support. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.fold_arith_extension' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyFoldArithExtensionPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyFoldArithExtensionPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.fold_arith_extension' .. py:function:: apply_patterns_vector_fold_arith_extension(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyFoldArithExtensionPatternsOp .. py:class:: ApplyFoldElementwiseToVectorPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Collect a set of patterns that fold elementwise op on vectors to the vector dialect. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.elementwise_to_vector' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyFoldElementwiseToVectorPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyFoldElementwiseToVectorPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.elementwise_to_vector' .. py:function:: apply_patterns_vector_elementwise_to_vector(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyFoldElementwiseToVectorPatternsOp .. py:class:: ApplyInterleaveAndDeinterleaveToShufflePatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.interleave_and_deinterleave_to_shuffle' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyInterleaveAndDeinterleaveToShufflePatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyInterleaveAndDeinterleaveToShufflePatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.interleave_and_deinterleave_to_shuffle' .. py:function:: apply_patterns_vector_interleave_and_deinterleave_to_shuffle(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyInterleaveAndDeinterleaveToShufflePatternsOp .. py:class:: ApplyLowerBitCastPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_bitcast' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerBitCastPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerBitCastPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_bitcast' .. py:function:: apply_patterns_vector_lower_bitcast(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerBitCastPatternsOp .. py:class:: ApplyLowerBroadcastPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_broadcast' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerBroadcastPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerBroadcastPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_broadcast' .. py:function:: apply_patterns_vector_lower_broadcast(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerBroadcastPatternsOp .. py:class:: ApplyLowerContractionPatternsOp(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_contraction' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lowering_strategy() -> _ods_ir .. py:class:: ApplyLowerContractionPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerContractionPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_contraction' .. py:method:: lowering_strategy() -> _ods_ir .. py:function:: apply_patterns_vector_lower_contraction(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerContractionPatternsOp .. py:class:: ApplyLowerCreateMaskPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Indicates that vector create_mask-like operations should be lowered to finer-grained vector primitives. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_create_mask' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerCreateMaskPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerCreateMaskPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_create_mask' .. py:function:: apply_patterns_vector_lower_create_mask(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerCreateMaskPatternsOp .. py:class:: ApplyLowerGatherPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Indicates that vector.gather operations should be lowered to finer-grained vector primitives. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_gather' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerGatherPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerGatherPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_gather' .. py:function:: apply_patterns_vector_lower_gather(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerGatherPatternsOp .. py:class:: ApplyLowerInterleavePatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_interleave' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerInterleavePatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerInterleavePatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_interleave' .. py:function:: apply_patterns_vector_lower_interleave(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerInterleavePatternsOp .. py:class:: ApplyLowerMaskedTransfersPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_masked_transfers' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerMaskedTransfersPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerMaskedTransfersPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_masked_transfers' .. py:function:: apply_patterns_vector_lower_masked_transfers(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerMaskedTransfersPatternsOp .. py:class:: ApplyLowerMasksPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_masks' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerMasksPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerMasksPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_masks' .. py:function:: apply_patterns_vector_lower_masks(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerMasksPatternsOp .. py:class:: ApplyLowerOuterProductPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_outerproduct' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerOuterProductPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerOuterProductPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_outerproduct' .. py:function:: apply_patterns_vector_lower_outerproduct(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerOuterProductPatternsOp .. py:class:: ApplyLowerScanPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Indicates that vector.scan operations should be lowered to finer-grained vector primitives. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_scan' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerScanPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerScanPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_scan' .. py:function:: apply_patterns_vector_lower_scan(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerScanPatternsOp .. py:class:: ApplyLowerShapeCastPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_shape_cast' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyLowerShapeCastPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerShapeCastPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_shape_cast' .. py:function:: apply_patterns_vector_lower_shape_cast(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerShapeCastPatternsOp .. py:class:: ApplyLowerStepPatternsOp(index_bitwidth: Union[int, _ods_ir], *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_step' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: index_bitwidth() -> _ods_ir .. py:class:: ApplyLowerStepPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerStepPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_step' .. py:method:: index_bitwidth() -> _ods_ir .. py:function:: apply_patterns_vector_lower_step(index_bitwidth: Union[int, _ods_ir], *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerStepPatternsOp .. py:class:: ApplyLowerTransferPatternsOp(*, max_transfer_rank: Optional[Union[int, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_transfer' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: max_transfer_rank() -> _ods_ir .. py:class:: ApplyLowerTransferPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerTransferPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_transfer' .. py:method:: max_transfer_rank() -> _ods_ir .. py:function:: apply_patterns_vector_lower_transfer(*, max_transfer_rank: Optional[Union[int, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerTransferPatternsOp .. py:class:: ApplyLowerTransposePatternsOp(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, avx2_lowering_strategy: Optional[Union[bool, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_transpose' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lowering_strategy() -> _ods_ir .. py:method:: avx2_lowering_strategy() -> _ods_ir .. py:class:: ApplyLowerTransposePatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyLowerTransposePatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.lower_transpose' .. py:method:: lowering_strategy() -> _ods_ir .. py:method:: avx2_lowering_strategy() -> _ods_ir .. py:function:: apply_patterns_vector_lower_transpose(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, avx2_lowering_strategy: Optional[Union[bool, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyLowerTransposePatternsOp .. py:class:: ApplyMaterializeMasksPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.materialize_masks' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyMaterializeMasksPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyMaterializeMasksPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.materialize_masks' .. py:function:: apply_patterns_vector_materialize_masks(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyMaterializeMasksPatternsOp .. py:class:: ApplyMultiReductionFlatteningPatternsOp(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Indicates that vector multi_reduction operations should be flattened from more than 2-D to 2-D. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.multi_reduction_flattening' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lowering_strategy() -> _ods_ir .. py:class:: ApplyMultiReductionFlatteningPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyMultiReductionFlatteningPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.multi_reduction_flattening' .. py:method:: lowering_strategy() -> _ods_ir .. py:function:: apply_patterns_vector_multi_reduction_flattening(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyMultiReductionFlatteningPatternsOp .. py:class:: ApplyMultiReductionUnrollingPatternsOp(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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) .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.multi_reduction_unrolling' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lowering_strategy() -> _ods_ir .. py:class:: ApplyMultiReductionUnrollingPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyMultiReductionUnrollingPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.multi_reduction_unrolling' .. py:method:: lowering_strategy() -> _ods_ir .. py:function:: apply_patterns_vector_multi_reduction_unrolling(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyMultiReductionUnrollingPatternsOp .. py:class:: ApplyRankReducingSubviewPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.rank_reducing_subview_patterns' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyRankReducingSubviewPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyRankReducingSubviewPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.rank_reducing_subview_patterns' .. py:function:: apply_patterns_vector_rank_reducing_subview_patterns(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyRankReducingSubviewPatternsOp .. py:class:: ApplyReorderMultiReductionPatternsOp(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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`` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.reorder_multi_reduction_dims' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lowering_strategy() -> _ods_ir .. py:class:: ApplyReorderMultiReductionPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyReorderMultiReductionPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.reorder_multi_reduction_dims' .. py:method:: lowering_strategy() -> _ods_ir .. py:function:: apply_patterns_vector_reorder_multi_reduction_dims(*, lowering_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyReorderMultiReductionPatternsOp .. py:class:: ApplyRewriteNarrowTypePatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.rewrite_narrow_types' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyRewriteNarrowTypePatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyRewriteNarrowTypePatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.rewrite_narrow_types' .. py:function:: apply_patterns_vector_rewrite_narrow_types(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyRewriteNarrowTypePatternsOp .. py:class:: ApplySinkVectorMemPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: vector.load %arg0[%arg1] : memref, vector<4xf32> vector.extract %0[1] : f32 from vector<4xf32> Gets converted to: .. code:: %c1 = arith.constant 1 : index %0 = arith.addi %arg1, %c1 overflow : index %1 = memref.load %arg0[%0] : memref .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.sink_mem_ops' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplySinkVectorMemPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplySinkVectorMemPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.sink_mem_ops' .. py:function:: apply_patterns_vector_sink_mem_ops(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplySinkVectorMemPatternsOp .. py:class:: ApplySinkVectorPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Patterns that remove redundant Vector Ops by re-ordering them with e.g. elementwise Ops. Example: .. code:: %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: .. code:: %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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.sink_ops' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplySinkVectorPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplySinkVectorPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.sink_ops' .. py:function:: apply_patterns_vector_sink_ops(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplySinkVectorPatternsOp .. py:class:: ApplySplitTransferFullPartialPatternsOp(*, split_transfer_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.split_transfer_full_partial' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: split_transfer_strategy() -> _ods_ir .. py:class:: ApplySplitTransferFullPartialPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplySplitTransferFullPartialPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.split_transfer_full_partial' .. py:method:: split_transfer_strategy() -> _ods_ir .. py:function:: apply_patterns_vector_split_transfer_full_partial(*, split_transfer_strategy: Optional[Union[Any, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplySplitTransferFullPartialPatternsOp .. py:class:: ApplyTransferPermutationPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.transfer_permutation_patterns' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyTransferPermutationPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyTransferPermutationPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.transfer_permutation_patterns' .. py:function:: apply_patterns_vector_transfer_permutation_patterns(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyTransferPermutationPatternsOp .. py:class:: ApplyTransferToScfPatternsOp(*, max_transfer_rank: Optional[Union[int, _ods_ir]] = None, full_unroll: Optional[Union[bool, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.transfer_to_scf' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: max_transfer_rank() -> _ods_ir .. py:method:: full_unroll() -> _ods_ir .. py:class:: ApplyTransferToScfPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyTransferToScfPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.transfer_to_scf' .. py:method:: max_transfer_rank() -> _ods_ir .. py:method:: full_unroll() -> _ods_ir .. py:function:: apply_patterns_vector_transfer_to_scf(*, max_transfer_rank: Optional[Union[int, _ods_ir]] = None, full_unroll: Optional[Union[bool, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyTransferToScfPatternsOp .. py:class:: ApplyUnrollFromElementsPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Indicates that vector from_elements operations should be unrolled along the outermost dimension. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.unroll_from_elements' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyUnrollFromElementsPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyUnrollFromElementsPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.unroll_from_elements' .. py:function:: apply_patterns_vector_unroll_from_elements(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyUnrollFromElementsPatternsOp .. py:class:: ApplyUnrollToElementsPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Indicates that vector to_elements operations should be unrolled along the outermost dimension. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.unroll_to_elements' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyUnrollToElementsPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyUnrollToElementsPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.unroll_to_elements' .. py:function:: apply_patterns_vector_unroll_to_elements(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyUnrollToElementsPatternsOp .. py:class:: ApplyVectorReductionToContractPatternsOp(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.reduction_to_contract' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:class:: ApplyVectorReductionToContractPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyVectorReductionToContractPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.reduction_to_contract' .. py:function:: apply_patterns_vector_reduction_to_contract(*, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyVectorReductionToContractPatternsOp .. py:class:: ApplyVectorToLLVMConversionPatternsOp(*, reassociate_fp_reductions: Optional[Union[bool, _ods_ir]] = None, force_32bit_vector_indices: Optional[Union[bool, _ods_ir]] = None, use_vector_alignment: Optional[Union[bool, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_conversion_patterns.vector.vector_to_llvm' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: reassociate_fp_reductions() -> _ods_ir .. py:method:: force_32bit_vector_indices() -> _ods_ir .. py:method:: use_vector_alignment() -> _ods_ir .. py:class:: ApplyVectorToLLVMConversionPatternsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ApplyVectorToLLVMConversionPatternsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'transform.apply_conversion_patterns.vector.vector_to_llvm' .. py:method:: reassociate_fp_reductions() -> _ods_ir .. py:method:: force_32bit_vector_indices() -> _ods_ir .. py:method:: use_vector_alignment() -> _ods_ir .. py:function:: apply_conversion_patterns_vector_vector_to_llvm(*, reassociate_fp_reductions: Optional[Union[bool, _ods_ir]] = None, force_32bit_vector_indices: Optional[Union[bool, _ods_ir]] = None, use_vector_alignment: Optional[Union[bool, _ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> ApplyVectorToLLVMConversionPatternsOp