mlir.dialects._vector_transform_ops_gen ======================================= .. py:module:: mlir.dialects._vector_transform_ops_gen Attributes ---------- .. autoapisummary:: mlir.dialects._vector_transform_ops_gen._ods_ir Classes ------- .. autoapisummary:: mlir.dialects._vector_transform_ops_gen.ApplyCastAwayVectorLeadingOneDimPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyDropUnitDimWithShapeCastPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyFoldArithExtensionPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyFoldElementwiseToVectorPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyInterleaveToShufflePatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerBitCastPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerBroadcastPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerContractionPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerCreateMaskPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerGatherPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerInterleavePatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerMaskedTransfersPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerMasksPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerMultiReductionPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerOuterProductPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerScanPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerShapeCastPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerTransferPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyLowerTransposePatternsOp mlir.dialects._vector_transform_ops_gen.ApplyMaterializeMasksPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyRankReducingSubviewPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyRewriteNarrowTypePatternsOp mlir.dialects._vector_transform_ops_gen.ApplySinkVectorMemPatternsOp mlir.dialects._vector_transform_ops_gen.ApplySinkVectorPatternsOp mlir.dialects._vector_transform_ops_gen.ApplySplitTransferFullPartialPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyTransferPermutationPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyTransferToScfPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyUnrollFromElementsPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyUnrollToElementsPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyVectorReductionToContractPatternsOp mlir.dialects._vector_transform_ops_gen.ApplyVectorToLLVMConversionPatternsOp 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_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_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_multi_reduction 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_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_rank_reducing_subview_patterns 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:class:: ApplyCastAwayVectorLeadingOneDimPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_cast_away_vector_leading_one_dim(*, loc=None, ip=None) -> ApplyCastAwayVectorLeadingOneDimPatternsOp .. py:class:: ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_drop_inner_most_unit_dims_from_xfer_ops(*, loc=None, ip=None) -> ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp .. py:class:: ApplyDropUnitDimWithShapeCastPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_drop_unit_dims_with_shape_cast(*, loc=None, ip=None) -> ApplyDropUnitDimWithShapeCastPatternsOp .. py:class:: ApplyFoldArithExtensionPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_fold_arith_extension(*, loc=None, ip=None) -> ApplyFoldArithExtensionPatternsOp .. py:class:: ApplyFoldElementwiseToVectorPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_elementwise_to_vector(*, loc=None, ip=None) -> ApplyFoldElementwiseToVectorPatternsOp .. py:class:: ApplyInterleaveToShufflePatternsOp(*, loc=None, ip=None) Bases: :py:obj:`_ods_ir` Indicates that 1D vector interleave operations should be rewritten as vector shuffle operations. This is motivated by some current codegen backends not handling vector interleave operations. .. py:attribute:: OPERATION_NAME :value: 'transform.apply_patterns.vector.interleave_to_shuffle' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:function:: apply_patterns_vector_interleave_to_shuffle(*, loc=None, ip=None) -> ApplyInterleaveToShufflePatternsOp .. py:class:: ApplyLowerBitCastPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_bitcast(*, loc=None, ip=None) -> ApplyLowerBitCastPatternsOp .. py:class:: ApplyLowerBroadcastPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_broadcast(*, loc=None, ip=None) -> ApplyLowerBroadcastPatternsOp .. py:class:: ApplyLowerContractionPatternsOp(*, lowering_strategy=None, loc=None, ip=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:function:: apply_patterns_vector_lower_contraction(*, lowering_strategy=None, loc=None, ip=None) -> ApplyLowerContractionPatternsOp .. py:class:: ApplyLowerCreateMaskPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_create_mask(*, loc=None, ip=None) -> ApplyLowerCreateMaskPatternsOp .. py:class:: ApplyLowerGatherPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_gather(*, loc=None, ip=None) -> ApplyLowerGatherPatternsOp .. py:class:: ApplyLowerInterleavePatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_interleave(*, loc=None, ip=None) -> ApplyLowerInterleavePatternsOp .. py:class:: ApplyLowerMaskedTransfersPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_masked_transfers(*, loc=None, ip=None) -> ApplyLowerMaskedTransfersPatternsOp .. py:class:: ApplyLowerMasksPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_masks(*, loc=None, ip=None) -> ApplyLowerMasksPatternsOp .. py:class:: ApplyLowerMultiReductionPatternsOp(*, lowering_strategy=None, loc=None, ip=None) Bases: :py:obj:`_ods_ir` Indicates that vector multi_reduction-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_multi_reduction' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lowering_strategy() -> _ods_ir .. py:function:: apply_patterns_vector_lower_multi_reduction(*, lowering_strategy=None, loc=None, ip=None) -> ApplyLowerMultiReductionPatternsOp .. py:class:: ApplyLowerOuterProductPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_outerproduct(*, loc=None, ip=None) -> ApplyLowerOuterProductPatternsOp .. py:class:: ApplyLowerScanPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_scan(*, loc=None, ip=None) -> ApplyLowerScanPatternsOp .. py:class:: ApplyLowerShapeCastPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_lower_shape_cast(*, loc=None, ip=None) -> ApplyLowerShapeCastPatternsOp .. py:class:: ApplyLowerTransferPatternsOp(*, max_transfer_rank=None, loc=None, ip=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:function:: apply_patterns_vector_lower_transfer(*, max_transfer_rank=None, loc=None, ip=None) -> ApplyLowerTransferPatternsOp .. py:class:: ApplyLowerTransposePatternsOp(*, lowering_strategy=None, avx2_lowering_strategy=None, loc=None, ip=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:function:: apply_patterns_vector_lower_transpose(*, lowering_strategy=None, avx2_lowering_strategy=None, loc=None, ip=None) -> ApplyLowerTransposePatternsOp .. py:class:: ApplyMaterializeMasksPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_materialize_masks(*, loc=None, ip=None) -> ApplyMaterializeMasksPatternsOp .. py:class:: ApplyRankReducingSubviewPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_rank_reducing_subview_patterns(*, loc=None, ip=None) -> ApplyRankReducingSubviewPatternsOp .. py:class:: ApplyRewriteNarrowTypePatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_rewrite_narrow_types(*, loc=None, ip=None) -> ApplyRewriteNarrowTypePatternsOp .. py:class:: ApplySinkVectorMemPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_sink_mem_ops(*, loc=None, ip=None) -> ApplySinkVectorMemPatternsOp .. py:class:: ApplySinkVectorPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_sink_ops(*, loc=None, ip=None) -> ApplySinkVectorPatternsOp .. py:class:: ApplySplitTransferFullPartialPatternsOp(*, split_transfer_strategy=None, loc=None, ip=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:function:: apply_patterns_vector_split_transfer_full_partial(*, split_transfer_strategy=None, loc=None, ip=None) -> ApplySplitTransferFullPartialPatternsOp .. py:class:: ApplyTransferPermutationPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_transfer_permutation_patterns(*, loc=None, ip=None) -> ApplyTransferPermutationPatternsOp .. py:class:: ApplyTransferToScfPatternsOp(*, max_transfer_rank=None, full_unroll=None, loc=None, ip=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:function:: apply_patterns_vector_transfer_to_scf(*, max_transfer_rank=None, full_unroll=None, loc=None, ip=None) -> ApplyTransferToScfPatternsOp .. py:class:: ApplyUnrollFromElementsPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_unroll_from_elements(*, loc=None, ip=None) -> ApplyUnrollFromElementsPatternsOp .. py:class:: ApplyUnrollToElementsPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_unroll_to_elements(*, loc=None, ip=None) -> ApplyUnrollToElementsPatternsOp .. py:class:: ApplyVectorReductionToContractPatternsOp(*, loc=None, ip=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:function:: apply_patterns_vector_reduction_to_contract(*, loc=None, ip=None) -> ApplyVectorReductionToContractPatternsOp .. py:class:: ApplyVectorToLLVMConversionPatternsOp(*, reassociate_fp_reductions=None, force_32bit_vector_indices=None, use_vector_alignment=None, loc=None, ip=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:function:: apply_conversion_patterns_vector_vector_to_llvm(*, reassociate_fp_reductions=None, force_32bit_vector_indices=None, use_vector_alignment=None, loc=None, ip=None) -> ApplyVectorToLLVMConversionPatternsOp