Diff 246697

mlir/include/mlir/Dialect/Linalg/IR/CMakeLists.txt

	add_mlir_dialect(LinalgOps LinalgDoc)			add_mlir_dialect(LinalgOps LinalgDoc)
	set(LLVM_TARGET_DEFINITIONS LinalgStructuredOps.td)			set(LLVM_TARGET_DEFINITIONS LinalgStructuredOps.td)
	mlir_tablegen(LinalgStructuredOps.h.inc -gen-op-decls)			mlir_tablegen(LinalgStructuredOps.h.inc -gen-op-decls)
	mlir_tablegen(LinalgStructuredOps.cpp.inc -gen-op-defs)			mlir_tablegen(LinalgStructuredOps.cpp.inc -gen-op-defs)
	mlir_tablegen(LinalgStructuredOpsInterfaces.h.inc -gen-op-interface-decls)
	mlir_tablegen(LinalgStructuredOpsInterfaces.cpp.inc -gen-op-interface-defs)
	add_public_tablegen_target(MLIRLinalgStructuredOpsIncGen)			add_public_tablegen_target(MLIRLinalgStructuredOpsIncGen)

				set(LLVM_TARGET_DEFINITIONS LinalgStructuredOpsInterface.td)
				mlir_tablegen(LinalgStructuredOpsInterfaces.h.inc -gen-op-interface-decls)
				mlir_tablegen(LinalgStructuredOpsInterfaces.cpp.inc -gen-op-interface-defs)
				add_public_tablegen_target(MLIRLinalgStructuredOpsInterfaceIncGen)

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.h

	Show All 21 Lines
	#include "mlir/IR/StandardTypes.h"			#include "mlir/IR/StandardTypes.h"
	#include "mlir/IR/TypeUtilities.h"			#include "mlir/IR/TypeUtilities.h"
	#include "mlir/IR/Types.h"			#include "mlir/IR/Types.h"
	#include "mlir/Support/LLVM.h"			#include "mlir/Support/LLVM.h"

	namespace mlir {			namespace mlir {
	namespace linalg {			namespace linalg {

				class ConvOp;

	/// Returns the name mangled library call name to disambiguate between different			/// Returns the name mangled library call name to disambiguate between different
	/// overloads at the C level. The name mangling scheme is basic and uses MLIR			/// overloads at the C level. The name mangling scheme is basic and uses MLIR
	/// type names:			/// type names:
	/// 1. form a string which is the concatenation of the linalg op name with all			/// 1. form a string which is the concatenation of the linalg op name with all
	/// the operand type names, separate by underscores;			/// the operand type names, separate by underscores;
	/// 2. drop the `linalg.` prefix, and the `<`, `>`, `?` symbols from the type.			/// 2. drop the `linalg.` prefix, and the `<`, `>`, `?` symbols from the type.
	/// Assumes `op` is a LinalgOp.			/// Assumes `op` is a LinalgOp.
	///			///
	Show All 9 Lines
	///			///
	/// 3. linalg.matmul(...) :			/// 3. linalg.matmul(...) :
	/// memref<?x?xf32, stride_specification>,			/// memref<?x?xf32, stride_specification>,
	/// memref<?x?xf32, stride_specification>,			/// memref<?x?xf32, stride_specification>,
	/// memref<?x?xf32, stride_specification>			/// memref<?x?xf32, stride_specification>
	/// name mangles into `linalg_matmul_viewxxf32_viewxxf32_viewxxf32_impl`			/// name mangles into `linalg_matmul_viewxxf32_viewxxf32_viewxxf32_impl`
	std::string generateLibraryCallName(Operation *op);			std::string generateLibraryCallName(Operation *op);

	/// Returns the list of maps that map loops to operands of a Linalg op.			/// Returns `num` AffineDimExpr dimensions at positions
	/// The i-th affine map identifies loop indices to subscripts that are used when			/// [startIdx, startIdx + num) and increments `startIdx` to `startIdx + num`.
	/// accessing the i-th operand.			SmallVector<AffineExpr, 4> makeAffineDimExprs(unsigned num, unsigned &startIdx,
	/// For instance, a matmul that can be written in index notation as:			MLIRContext *context);
	/// `A(i, k) * B(k, j) -> C(i, j)` will have the following, ordered, list of
	/// affine maps:			/// Builds the indexing expressions for a ConvOp `op`. Returns the vector of
				rriddleUnsubmitted Done Reply Inline Actions nit: Please move forward declarations to the top. rriddle: nit: Please move forward declarations to the top.
	///			/// AffineMaps representing:
	/// ```mlir			/// `stride[i] * xs[i] + dilation[i] * zs[i]`
	/// (			SmallVector<AffineExpr, 4> weightedConvInputIndex(ConvOp op,
	/// (i, j, k) -> (i, k),			ArrayRef<AffineExpr> xs,
	/// (i, j, k) -> (k, j),			ArrayRef<AffineExpr> zs);
	/// (i, j, k) -> (i, j)
	/// )			/// Returns `maybeMap.get()` if `maybeMap` is set, otherwise returns the
	/// ```			/// symbol-less identity map of `rank`.
	///			AffineMap extractOrIdentityMap(Optional<AffineMap> maybeMap, unsigned rank,
	/// Only permutation maps are currently supported.			MLIRContext *context);
	SmallVector<AffineMap, 4> loopToOperandRangesMaps(Operation *op);
				/// Return the vector that is the concatenation of `a` and `b`.
				SmallVector<AffineExpr, 4> concat(ArrayRef<AffineExpr> a,
				ArrayRef<AffineExpr> b);

	#include "mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterfaces.h.inc"			#include "mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterfaces.h.inc"

	#define GET_OP_CLASSES			#define GET_OP_CLASSES
	#include "mlir/Dialect/Linalg/IR/LinalgOps.h.inc"			#include "mlir/Dialect/Linalg/IR/LinalgOps.h.inc"

	#define GET_OP_CLASSES			#define GET_OP_CLASSES
	#include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.h.inc"			#include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.h.inc"

	} // namespace linalg			} // namespace linalg
	} // namespace mlir			} // namespace mlir

	#endif // MLIR_DIALECT_LINALG_LINALGOPS_H_			#endif // MLIR_DIALECT_LINALG_LINALGOPS_H_

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

Show All 10 Lines
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#ifndef LINALG_STRUCTURED_OPS		#ifndef LINALG_STRUCTURED_OPS
#define LINALG_STRUCTURED_OPS		#define LINALG_STRUCTURED_OPS

include "mlir/Dialect/AffineOps/AffineOpsBase.td"		include "mlir/Dialect/AffineOps/AffineOpsBase.td"
include "mlir/Dialect/Linalg/IR/LinalgBase.td"		include "mlir/Dialect/Linalg/IR/LinalgBase.td"
		include "mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td"

// The Linalg `NInputs` trait provides the API for ops that are known		// The Linalg `NInputs` trait provides the API for ops that are known
// to have a specified number of inputs, all passed as operands.		// to have a specified number of inputs, all passed as operands.
// See Linalg/LinalgTraits.h for implementation details an usage.		// See Linalg/LinalgTraits.h for implementation details an usage.
class NInputs<int args_in> :		class NInputs<int args_in> :
NativeOpTrait<"linalg::NInputs<" # !cast<string>(args_in) # ">::Impl"> {}		NativeOpTrait<"linalg::NInputs<" # !cast<string>(args_in) # ">::Impl"> {}

// The Linalg `NOutputs` trait provides the API for ops that are known		// The Linalg `NOutputs` trait provides the API for ops that are known
// to have a specified number of outputs, all passed as operands.		// to have a specified number of outputs, all passed as operands.
// See Linalg/LinalgTraits.h for implementation details an usage.		// See Linalg/LinalgTraits.h for implementation details an usage.
class NOutputs<int args_out> :		class NOutputs<int args_out> :
NativeOpTrait<"linalg::NOutputs<" # !cast<string>(args_out) # ">::Impl"> {}		NativeOpTrait<"linalg::NOutputs<" # !cast<string>(args_out) # ">::Impl"> {}

def StructuredOpTraits : NativeOpTrait<"linalg::StructuredOpTraits">;		def StructuredOpTraits : NativeOpTrait<"linalg::StructuredOpTraits">;

// The linalg 'LinalgStructuredInterface' provides access to the 'LinalgOp'
// interface.
def LinalgStructuredInterface : OpInterface<"LinalgOp"> {
let methods = [
//========================================================================//
// Loop types handling.
//========================================================================//
InterfaceMethod<
"Return the number of parallel loops within the current operation.",
"unsigned", "getNumParallelLoops"
>,
InterfaceMethod<
"Return the number of reduction loops within the current operation.",
"unsigned", "getNumReductionLoops"
>,
InterfaceMethod<
"Return the number of window loops within the current operation.",
"unsigned", "getNumWindowLoops"
>,
InterfaceMethod<
"Return the number of loops within the current operation.",
"unsigned", "getNumLoops">,

InterfaceMethod<
[{Returns true if the current operation has only one loop and it's a
reduction loop}],
"unsigned", "hasSingleReductionLoop">,

//========================================================================//
// Input arguments handling.
//========================================================================//
InterfaceMethod<
"Return the number of inputs from the current operation.",
"unsigned", "getNumInputs"
>,
InterfaceMethod<"Return the input view at the given index.",
"Value ", "getInput", (ins "unsigned":$i)
>,
InterfaceMethod<[{
Return the index of the given input value `v`, or `None` if the value is
not an input.
}],
"llvm::Optional<unsigned>", "getIndexOfInput", (ins "Value ":$v)
>,
InterfaceMethod<
"Return the input operands from the current operation.",
"Operation::operand_range", "getInputs"
>,
InterfaceMethod<[{
Return the type of the input shape at the given index.
}], "ShapedType", "getInputShapedType", (ins "unsigned":$i)>,
InterfaceMethod<[{
Return the subset of input operands that are of ranked tensor type.
}], "SmallVector<RankedTensorType, 4>", "getInputTensorTypes">,

//========================================================================//
// Output arguments handling.
//========================================================================//
InterfaceMethod<
"Return the number of outputs from the current operation.",
"unsigned", "getNumOutputs"
>,
InterfaceMethod<"Return the output buffer at the given index.",
"Value ", "getOutputBuffer", (ins "unsigned":$i)
>,
InterfaceMethod<[{
Return the index of the given buffer value, or `None` if the value is
not part of the output buffers.
}],
"llvm::Optional<unsigned>", "getIndexOfOutputBuffer", (ins "Value ":$view)
>,
InterfaceMethod<[{
Return the type of the output buffer at the given index.
}], "MemRefType", "getOutputBufferType", (ins "unsigned":$i)>,
InterfaceMethod<[{
Return the results that are of ranked tensor type.
}], "SmallVector<RankedTensorType, 4>", "getOutputTensorTypes">,
InterfaceMethod<
"Return the output buffers (operands) from the current operation.",
"Operation::operand_range", "getOutputBuffers"
>,

//========================================================================//
// Input and Output arguments handling.
//========================================================================//
InterfaceMethod<
"Return the number of inputs and outputs, irrespective of their buffer "
"or tensor type.",
"unsigned", "getNumInputsAndOutputs"
>,
InterfaceMethod<
"Return the number of inputs, irrespective of their buffer or tensor "
"type, and output buffers",
"unsigned", "getNumInputsAndOutputBuffers"
>,
InterfaceMethod<
"Return the range over inputs (irrespective of type) and output buffers.",
"Operation::operand_range", "getInputsAndOutputBuffers"
>,

//========================================================================//
// Other interface methods.
//========================================================================//
InterfaceMethod<
"Return the reference iterators for this named op (if any are specied). "
"These reference iterators are used to specify the default behavior of "
"the op. Typically this would be a static method but in order to allow "
"rank-polymorphic ops, this needs to be per object instance. Named ops "
"must define referenceIterators, even if empty for the 0-D case. "
"Generic ops on the other hand have a None `referenceIterators`",
"llvm::Optional<SmallVector<StringRef, 8>>", "referenceIterators"
>,
InterfaceMethod<
"Return the reference indexing maps for this named op (if any are "
"specified). Typically this would be a static method but in order to "
"allow rank-polymorphic ops, this needs to be per object instance. Named "
"ops must define referenceIterators, even if empty for the 0-D case. "
"Generic ops on the other hand have a None `referenceIndexingMaps`",
"llvm::Optional<SmallVector<AffineMap, 8>>", "referenceIndexingMaps"
>,
InterfaceMethod<
"Return the iterator types attribute within the current operation.",
"ArrayAttr", "iterator_types"
>,
InterfaceMethod<
"Return the indexing maps attribute within the current operation.",
"ArrayAttr", "indexing_maps"
>,
InterfaceMethod<"Return the input or output indexing map at index `i`.",
"AffineMap", "getIndexingMap", (ins "unsigned":$i)
>,
InterfaceMethod<"Return the input indexing map at index `i`.",
"AffineMap", "getInputIndexingMap", (ins "unsigned":$i)
>,
InterfaceMethod<"Return the output indexing map at index `i`.",
"AffineMap", "getOutputIndexingMap", (ins "unsigned":$i)
>,
InterfaceMethod<[{
Return whether the op has only MemRef input and outputs.
}], "bool", "hasBufferSemantics">,
InterfaceMethod<[{
Return whether the op has only RankedTensor input and outputs.
}], "bool", "hasTensorSemantics">,

//========================================================================//
// Other static interface methods.
//========================================================================//
StaticInterfaceMethod<[{
Create an operation of the current type with the given location,
operands, and attributes.
}],
"Operation *", "create",
(ins "OpBuilder &":$builder, "Location":$loc,
"ValueRange":$operands,
"ArrayRef<NamedAttribute>":$attributes), [{
return builder.create<ConcreteOp>(loc, ArrayRef<Type>{}, operands,
attributes);
}]
>,
InterfaceMethod<[{
Clone the current operation with the given location and operands. This
is used to abstract away the optional underlying region creation.
}],
"Operation *", "clone",
(ins "OpBuilder &":$b, "Location":$loc, "ValueRange":$operands), [{
BlockAndValueMapping map;
unsigned numRegions = op.getOperation()->getNumRegions();
Operation *res = create(b, loc, operands, op.getAttrs());
assert(res->getNumRegions() == numRegions && "inconsistent # regions");
for (unsigned ridx = 0; ridx < numRegions; ++ridx)
op.getOperation()->getRegion(ridx).cloneInto(
&res->getRegion(ridx), map);
return res;
}]
>
];
}

// Base Tablegen class for Linalg ops.		// Base Tablegen class for Linalg ops.
// Linalg ops that correspond to library calls operate on linalg::View as their		// Linalg ops that correspond to library calls operate on linalg::View as their
// first operands. These may be optionally followed by non-view operands		// first operands. These may be optionally followed by non-view operands
// depending on the specific Linalg op.		// depending on the specific Linalg op.
class LinalgStructuredBase_Op<string mnemonic, list<OpTrait> props>		class LinalgStructuredBase_Op<string mnemonic, list<OpTrait> props>
: Op<Linalg_Dialect, mnemonic,		: Op<Linalg_Dialect, mnemonic,
!listconcat(props, [StructuredOpTraits, LinalgStructuredInterface])> {		!listconcat(props, [StructuredOpTraits, LinalgStructuredInterface])> {
}		}

class LinalgStructured_Op<string mnemonic, list<OpTrait> props>		class LinalgStructured_Op<string mnemonic, list<OpTrait> props>
: LinalgStructuredBase_Op<mnemonic, props> {		: LinalgStructuredBase_Op<mnemonic, props> {
code libraryCallName = [{		code libraryCallName = [{
std::string getLibraryCallName() {		std::string getLibraryCallName() {
return generateLibraryCallName(getOperation());		return generateLibraryCallName(getOperation());
}		}
}];		}];
let assemblyFormat = "`(` operands `)` attr-dict `:` type(operands)";		let assemblyFormat = "`(` operands `)` attr-dict `:` type(operands)";
}		}

////////////////////////////////////////////////////////////////////////////////		//===----------------------------------------------------------------------===//
// Named Linalg ops, implemented as special configurations of a generic op.		// Named Linalg ops, implemented as special configurations of generic ops.
////////////////////////////////////////////////////////////////////////////////		//===----------------------------------------------------------------------===//
		// At the moment these are not declarative and require a bunch of C++ code.
		// In the future, these should be migrated to a declarative specification.
def CopyOp : LinalgStructured_Op<"copy", [NInputs<1>, NOutputs<1>]> {		def CopyOp : LinalgStructured_Op<"copy", [NInputs<1>, NOutputs<1>]> {
let description = [{		let description = [{
Copies the data in the input view into the output view.		Copies the data in the input view into the output view.

Usage:		Usage:
```mlir		```mlir
linalg.copy(%arg0, %arg1) : memref<?xf32, stride_specification>,		linalg.copy(%arg0, %arg1) : memref<?xf32, stride_specification>,
memref<?xf32, stride_specification>		memref<?xf32, stride_specification>
```		```

One possible lowering to loop form is:		One possible lowering to loop form is:
```mlir		```mlir
%0 = linalg.dim %arg0, 0 : index		%0 = linalg.dim %arg0, 0 : index
loop.for %i0 = %c0 to %0 step %c1 {		loop.for %i0 = %c0 to %0 step %c1 {
%1 = linalg.load %arg0[%i0] : memref<?xf32, stride_specification>		%1 = load %arg0[%i0] : memref<?xf32, stride_specification>
linalg.store %1, %arg1[%i0] : memref<?xf32, stride_specification>		store %1, %arg1[%i0] : memref<?xf32, stride_specification>
}		}
```		```

Optionally, can take `input_permutation` and `output_permutation` attributes		Optionally, can take `input_permutation` and `output_permutation` attributes
to reorder the dimensions of the input and output views.		to reorder the dimensions of the input and output views.

Usage:		Usage:
```mlir		```mlir
linalg.copy(%arg0, %arg1) {inputPermutation : (i, j, k) -> (i, k, j),		linalg.copy(%arg0, %arg1) {inputPermutation : (i, j, k) -> (i, k, j),
outputPermutation : (i, j, k) -> (k, j, i)} :		outputPermutation : (i, j, k) -> (k, j, i)} :
memref<?x?x?xf32, stride_specification>,		memref<?x?x?xf32, stride_specification>,
memref<?x?x?xf32, stride_specification>		memref<?x?x?xf32, stride_specification>
```		```

One possible lowering to loop form is:		One possible lowering to loop form is:
```mlir		```mlir
%0 = linalg.dim %arg0, 0		%0 = linalg.dim %arg0, 0
%1 = linalg.dim %arg0, 1		%1 = linalg.dim %arg0, 1
%2 = linalg.dim %arg0, 2		%2 = linalg.dim %arg0, 2
loop.for %i0 = %c0 to %{{.*}} step %c1 {		loop.for %i0 = %c0 to %{{.*}} step %c1 {
loop.for %i1 = %c0 to %{{.*}} step %c1 {		loop.for %i1 = %c0 to %{{.*}} step %c1 {
loop.for %i2 = %c0 to %{{.*}} step %c1 {		loop.for %i2 = %c0 to %{{.*}} step %c1 {
%3 = linalg.load %arg0[%i0, %i2, %i1] :		%3 = load %arg0[%i0, %i2, %i1] :
memref<?x?x?xf32, stride_specification>		memref<?x?x?xf32, stride_specification>
linalg.store %3, %arg1[%i2, %i1, %i0] :		store %3, %arg1[%i2, %i1, %i0] :
memref<?x?x?xf32, stride_specification>		memref<?x?x?xf32, stride_specification>
```		```

The views are expected to be compatible for correctness but this is not		The views are expected to be compatible for correctness but this is not
enforced at the moment.		enforced at the moment.
}];		}];

let arguments = (ins		let arguments = (ins
AnyStridedMemRef:$input,		AnyStridedMemRef:$input,
AnyStridedMemRef:$output,		AnyStridedMemRef:$output,
OptionalAttr<AffineMapAttr>:$inputPermutation,		OptionalAttr<AffineMapAttr>:$inputPermutation,
OptionalAttr<AffineMapAttr>:$outputPermutation);		OptionalAttr<AffineMapAttr>:$outputPermutation);

// TODO(ntv) this should go away once the usage of OptionalAttr triggers		// TODO(ntv) this should go away once the usage of OptionalAttr triggers
// emission of builders with default arguments left unspecified.		// emission of builders with default arguments left unspecified.
let builders = [OpBuilder<		let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value input, Value output", [{		"Builder *builder, OperationState &result, Value input, Value output", [{
return build(		return build(
builder, result, input, output, AffineMapAttr(), AffineMapAttr());		builder, result, input, output, AffineMapAttr(), AffineMapAttr());
}]>];		}]>];
let extraClassDeclaration = libraryCallName # [{
// Defined in C++ for now.
// TODO(ntv): auto-generate.
ArrayAttr indexing_maps();

		let extraClassDeclaration = libraryCallName # [{
// Rank-polymorphic.		// Rank-polymorphic.
// filling_value -> O(ivs) with parallel iterators.		// filling_value -> O(ivs) with parallel iterators.
llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {		llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {
unsigned nPar = input().getType().cast<ShapedType>().getRank();		unsigned nPar = input().getType().cast<ShapedType>().getRank();
return SmallVector<StringRef, 8>(nPar, getParallelIteratorTypeName());		return SmallVector<StringRef, 8>(nPar, getParallelIteratorTypeName());
}		}

		// I(input_perm(ivs)) -> O(output_perm(ivs))
llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {		llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {
llvm_unreachable("NYI referenceIndexingMaps for CopyOp");		MLIRContext *context = getContext();
		auto maybeInputMap = inputPermutation();
		auto maybeOutputMap = outputPermutation();
		unsigned inputRank = getInputShapedType(0).getRank();
		unsigned outputRank = getOutputShapedType(0).getRank();
		return SmallVector<AffineMap, 8>{
		extractOrIdentityMap(maybeInputMap, inputRank, context),
		extractOrIdentityMap(maybeOutputMap, outputRank, context)};
}		}
}];		}];
let verifier = [{ return ::verify(*this); }];		let verifier = [{ return ::verify(*this); }];

let hasFolder = 1;		let hasFolder = 1;
}		}

def FillOp : LinalgStructured_Op<"fill", [NInputs<0>, NOutputs<1>]> {		def FillOp : LinalgStructured_Op<"fill", [NInputs<0>, NOutputs<1>]> {

let arguments = (ins AnyStridedMemRef:$output,		let arguments = (ins AnyStridedMemRef:$output,
AnyTypeOf<[AnyFloat, AnySignlessInteger, AnyVector]>:$value);		AnyTypeOf<[AnyFloat, AnySignlessInteger, AnyVector]>:$value);
let extraClassDeclaration = libraryCallName # [{		let extraClassDeclaration = libraryCallName # [{
// Defined in C++ for now.
// TODO(ntv): auto-generate.
ArrayAttr indexing_maps();

// Rank-polymorphic.		// Rank-polymorphic.
// filling_value -> O(ivs) with parallel iterators.		// filling_value -> O(ivs) with parallel iterators.
llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {		llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {
unsigned nPar = output().getType().cast<ShapedType>().getRank();		unsigned nPar = output().getType().cast<ShapedType>().getRank();
return SmallVector<StringRef, 8>(nPar, getParallelIteratorTypeName());		return SmallVector<StringRef, 8>(nPar, getParallelIteratorTypeName());
}		}

llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {		llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {
llvm_unreachable("NYI referenceIndexingMaps for CopyOp");		MLIRContext *context = getContext();
		// filling_value -> O(ivs)
		return SmallVector<AffineMap, 8>{
		extractOrIdentityMap(llvm::None, getNumParallelLoops(), context)};
}		}
}];		}];

let verifier = [{ return ::verify(*this); }];		let verifier = [{ return ::verify(*this); }];

let hasFolder = 1;		let hasFolder = 1;
}		}

def DotOp : LinalgStructured_Op<"dot", [NInputs<2>, NOutputs<1>]> {		def DotOp : LinalgStructured_Op<"dot", [NInputs<2>, NOutputs<1>]> {

let arguments = (ins AnyStridedMemRefOfRank<1>,		let arguments = (ins AnyStridedMemRefOfRank<1>,
AnyStridedMemRefOfRank<1>,		AnyStridedMemRefOfRank<1>,
AnyStridedMemRefOfRank<0>);		AnyStridedMemRefOfRank<0>);
let extraClassDeclaration = libraryCallName # [{
// Defined in C++ for now.
// TODO(ntv): auto-generate.
ArrayAttr indexing_maps();

		let extraClassDeclaration = libraryCallName # [{
llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {		llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {
return SmallVector<StringRef, 8>{getReductionIteratorTypeName()};		return SmallVector<StringRef, 8>{getReductionIteratorTypeName()};
}		}

		// A(r_i) * B(r_i) -> C()
llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {		llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {
llvm_unreachable("NYI referenceIndexingMaps for DotOp");		MLIRContext *context = getContext();
		auto r_i = getAffineDimExpr(0, context);
		return SmallVector<AffineMap, 8>{
		AffineMap::get(1, 0, {r_i}), AffineMap::get(1, 0, {r_i}), AffineMap()};
}		}
}];		}];

let hasFolder = 1;		let hasFolder = 1;
}		}

def MatvecOp : LinalgStructured_Op<"matvec", [NInputs<2>, NOutputs<1>]> {		def MatvecOp : LinalgStructured_Op<"matvec", [NInputs<2>, NOutputs<1>]> {

let arguments = (ins AnyStridedMemRefOfRank<2>,		let arguments = (ins AnyStridedMemRefOfRank<2>,
AnyStridedMemRefOfRank<1>,		AnyStridedMemRefOfRank<1>,
AnyStridedMemRefOfRank<1>);		AnyStridedMemRefOfRank<1>);
let extraClassDeclaration = libraryCallName # [{
// Defined in C++ for now.
// TODO(ntv): auto-generate.
ArrayAttr indexing_maps();

		let extraClassDeclaration = libraryCallName # [{
llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {		llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {
return SmallVector<StringRef, 8>{		return SmallVector<StringRef, 8>{
getParallelIteratorTypeName(),		getParallelIteratorTypeName(), getReductionIteratorTypeName()};
getReductionIteratorTypeName()};
}		}

		// A(i, r_j) * B(r_j) -> C(i)
llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {		llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {
llvm_unreachable("NYI referenceIndexingMaps for MatvecOp");		MLIRContext *context = getContext();
		AffineExpr i, r_j;
		bindDims(context, i, r_j);
		return SmallVector<AffineMap, 8>{
		AffineMap::get(2, 0, {i, r_j}), AffineMap::get(2, 0, {r_j}),
		AffineMap::get(2, 0, {i})};
}		}
}];		}];

let hasFolder = 1;		let hasFolder = 1;
}		}

def MatmulOp : LinalgStructured_Op<"matmul", [NInputs<2>, NOutputs<1>]> {		def MatmulOp : LinalgStructured_Op<"matmul", [NInputs<2>, NOutputs<1>]> {

let arguments = (ins AnyStridedMemRefOfRank<2>,		let arguments = (ins AnyStridedMemRefOfRank<2>,
AnyStridedMemRefOfRank<2>,		AnyStridedMemRefOfRank<2>,
AnyStridedMemRefOfRank<2>);		AnyStridedMemRefOfRank<2>);
let extraClassDeclaration = libraryCallName # [{
// Defined in C++ for now.
// TODO(ntv): auto-generate.
ArrayAttr indexing_maps();

		let extraClassDeclaration = libraryCallName # [{
llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {		llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {
return SmallVector<StringRef, 8>{		return SmallVector<StringRef, 8>{
getParallelIteratorTypeName(),		getParallelIteratorTypeName(),
getParallelIteratorTypeName(),		getParallelIteratorTypeName(),
getReductionIteratorTypeName()};		getReductionIteratorTypeName()};
}		}

		// A(i, r_k) * B(r_k, j) -> C(i, j)
llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {		llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {
llvm_unreachable("NYI referenceIndexingMaps for MatmulOp");		MLIRContext *context = getContext();
		AffineExpr i, j, r_k;
		bindDims(context, i, j, r_k);
		return SmallVector<AffineMap, 8>{AffineMap::get(3, 0, {i, r_k}),
		AffineMap::get(3, 0, {r_k, j}),
		AffineMap::get(3, 0, {i, j})};
}		}
}];		}];

let hasFolder = 1;		let hasFolder = 1;
}		}

def ConvOp : LinalgStructured_Op<"conv", [NInputs<2>, NOutputs<1>]> {		def ConvOp : LinalgStructured_Op<"conv", [NInputs<2>, NOutputs<1>]> {

let description = [{		let description = [{
Generic n-D convolution as described in the TF documentation:		Generic n-D convolution as described in the TF documentation:
https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/nn/convolution		https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/nn/convolution

```		```
output[b, x[0], ..., x[N-1], k] =		output[b, x[0], ..., x[N-1], k] =
sum_{z[0], ..., z[N-1], q}		sum_{z[0], ..., z[N-1], q}
filter[z[0], ..., z[N-1], q, k] *		filter[z[0], ..., z[N-1], q, k] *
padded_input[b,		padded_input[b,
x[0] * strides[0] + dilation_rate[0] * z[0],		x[0] * strides[0] + dilation_rate[0] * z[0],
...,		...,
x[N-1] * strides[N-1] + dilation_rate[N-1] * z[N-1],		x[N-1] * strides[N-1] + dilation_rate[N-1] * z[N-1],
q]		q]
```		```
}];		}];

// TODO(ntv) padding.		// TODO(ntv) padding.
// Following the TF source of truth above, strides and dilations are integer		// Following the TF source of truth above, strides and dilations are integer
// attributes of the same rank as the number of window dimensions.		// attributes of the same rank as the number of window dimensions.
let arguments = (ins AnyStridedMemRef:$filter, AnyStridedMemRef:$input,		let arguments = (ins AnyStridedMemRef:$filter, AnyStridedMemRef:$input,
AnyStridedMemRef:$output,		AnyStridedMemRef:$output,
OptionalAttr<I64ArrayAttr>:$strides,		OptionalAttr<I64ArrayAttr>:$strides,
OptionalAttr<I64ArrayAttr>:$dilations);		OptionalAttr<I64ArrayAttr>:$dilations);

let extraClassDeclaration = libraryCallName # [{		let extraClassDeclaration = libraryCallName # [{
// TODO(ntv) extend to support more than 1 dimensions and potentially		// TODO(ntv) extend to support more than 1 dimensions and potentially
// grouping too.		// grouping too.
unsigned getNumBatchDimensions() { return 1; }		unsigned getNumBatchDimensions() { return 1; }

unsigned getNumInputFeatureDimensions() { return 1; }		unsigned getNumInputFeatureDimensions() { return 1; }
unsigned getNumOutputFeatureDimensions() { return 1; }

// Defined in C++ for now.		unsigned getNumOutputFeatureDimensions() { return 1; }
// TODO(ntv): auto-generate.
ArrayAttr indexing_maps();

llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {		llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {
// Outer parallel loops are always the number of output dimensions; i.e.		// Outer parallel loops are always the number of output dimensions; i.e.
// [b, xs, q] in the TF notation above.		// [b, xs, q] in the TF notation above.
unsigned nPar = getOutputShapedType(0).getRank();		unsigned nPar = getOutputShapedType(0).getRank();
unsigned nRed = getNumInputFeatureDimensions();		unsigned nRed = getNumInputFeatureDimensions();
// Window loops are a special kind of reduction that is never tiled or		// Window loops are a special kind of reduction that is never tiled or
// parallelized across; i.e. [zs] in the TF notation above whose number		// parallelized across; i.e. [zs] in the TF notation above whose number
Show All 17 Lines	let extraClassDeclaration = libraryCallName # [{

int64_t getDilation(unsigned i) {		int64_t getDilation(unsigned i) {
assert(i < getNumWindowLoops());		assert(i < getNumWindowLoops());
if (!dilations().hasValue()) return 1;		if (!dilations().hasValue()) return 1;
return dilations()->getValue()[i]		return dilations()->getValue()[i]
.cast<IntegerAttr>().getValue().getSExtValue();		.cast<IntegerAttr>().getValue().getSExtValue();
}		}

		// F(z0, ..., zN-1, q, k) * I(b, x0 + z0, ..., xN-1 + zN-1, q) ->
		// O(b, x0, ..., xN-1, k)
		// for N equal to `nWindow`.
llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {		llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {
llvm_unreachable("NYI referenceIndexingMaps for MatmulOp");		MLIRContext *context = getContext();
		auto nWin = getNumWindowLoops();
		assert(nWin > 0 && "expected at least one window dimension");
		unsigned idx = 0;
		// In the following, AffineDimExprs are indexed in loop order:
		// [ b, xs, k, q, zs]
		// parallels non-window reductions windows
		//
		// Parallel dims are exactly the dimensions indexing `output`:
		// output[b, x[0], ..., x[N-1], k]; i.e.
		// * batch dimensions (bs with #bs = 1 for now)
		// * "image" dimensions (xs with #xs = #zs = output_rank - #bs - #ks)
		// * output filter dimensions (ks with #ks = 1 for now)
		auto bs = makeAffineDimExprs(getNumBatchDimensions(), idx, context);
		auto xs = makeAffineDimExprs(nWin, idx, context);
		auto ks = makeAffineDimExprs(
		getNumOutputFeatureDimensions(), idx, context);
		// Non-window reduction dim: sum_{z[0], ..., z[N-1], q}
		auto qs = makeAffineDimExprs(
		getNumInputFeatureDimensions(), idx, context);
		// Window reduction dims: sum_{z[0], ..., z[N-1], q}
		auto zs = makeAffineDimExprs(nWin, idx, context);
		// Construct the weighedSum expression.
		auto ws = weightedConvInputIndex(*this, xs, zs);
		return SmallVector<AffineMap, 8>{
		// filter[z[0], ..., z[N-1], q, k]
		AffineMap::get(idx, 0, concat(concat(zs, qs), ks)),
		// input[b,
		// x[0]s[0] + d[0]z[0], ..., x[N-1]s[N-1] + d[N-1]z[N-1],
		// q]
		AffineMap::get(idx, 0, concat(concat(bs, ws), qs)),
		// output[b, x[0], ..., x[N-1], k]
		AffineMap::get(idx, 0, concat(concat(bs, xs), ks))};
}		}
}];		}];

let verifier = [{ return ::verify(*this); }];		let verifier = [{ return ::verify(*this); }];

let hasFolder = 1;		let hasFolder = 1;
}		}

		//===----------------------------------------------------------------------===//
		// Generic Linalg ops.
		rriddleUnsubmitted Done Reply Inline Actions Can you please use the standardized format: https://github.com/llvm/llvm-project/blob/b3e6487f02ac98b6c4a501f5da10c867bd98f769/mlir/lib/IR/Block.cpp#L15 rriddle: Can you please use the standardized format: https://github.com/llvm/llvm…
		//===----------------------------------------------------------------------===//
def LinalgOperand: Type<		def LinalgOperand: Type<
Or<[AnyRankedTensor.predicate, AnyStridedMemRef.predicate]>>;		Or<[AnyRankedTensor.predicate, AnyStridedMemRef.predicate]>>;

class LinalgOperandOfRank<int rank>: Type<		class LinalgOperandOfRank<int rank>: Type<
And<[		And<[
LinalgOperand.predicate,		LinalgOperand.predicate,
CPred<"$_self.cast<ShapedType>().getRank() == " # rank>]		CPred<"$_self.cast<ShapedType>().getRank() == " # rank>]
>>;		>>;

////////////////////////////////////////////////////////////////////////////////
// Generic Linalg ops.
////////////////////////////////////////////////////////////////////////////////
class GenericOpBase<string mnemonic> : LinalgStructuredBase_Op<mnemonic, []> {		class GenericOpBase<string mnemonic> : LinalgStructuredBase_Op<mnemonic, []> {
let arguments = (ins Variadic<LinalgOperand>:$views,		let arguments = (ins Variadic<LinalgOperand>:$views,
I64Attr:$args_in,		I64Attr:$args_in,
I64Attr:$args_out,		I64Attr:$args_out,
AffineMapArrayAttr:$indexing_maps,		AffineMapArrayAttr:$indexing_maps,
ArrayAttr:$iterator_types,		ArrayAttr:$iterator_types,
OptionalAttr<StrAttr>:$doc,		OptionalAttr<StrAttr>:$doc,
OptionalAttr<FlatSymbolRefAttr>:$fun,		OptionalAttr<FlatSymbolRefAttr>:$fun,
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines	This may lower to either:
-> ()		-> ()
```		```

or IR resembling:		or IR resembling:
```mlir		```mlir
loop.for %m = %c0 to %M step %c1 {		loop.for %m = %c0 to %M step %c1 {
loop.for %n = %c0 to %N step %c1 {		loop.for %n = %c0 to %N step %c1 {
loop.for %k = %c0 to %K step %c1 {		loop.for %k = %c0 to %K step %c1 {
%a = linalg.load %A[%m, %k] : memref<?x?xf32, stride_specification>		%a = load %A[%m, %k] : memref<?x?xf32, stride_specification>
%b = linalg.load %B[%k, %n] : memref<?x?xf32, stride_specification>		%b = load %B[%k, %n] : memref<?x?xf32, stride_specification>
%c = linalg.load %C[%m, %n] : memref<?x?xf32, stride_specification>		%c = load %C[%m, %n] : memref<?x?xf32, stride_specification>
%d = call @func_of_elements(%a, %b, %c)		%d = call @func_of_elements(%a, %b, %c)
: (f32, f32, f32) -> (f32)		: (f32, f32, f32) -> (f32)
linalg.store %d, %C[%m, %n] : memref<?x?x?xf32, stride_specification>		store %d, %C[%m, %n] : memref<?x?x?xf32, stride_specification>
}		}
}		}
}		}
```		```

To allow progressive lowering from the value world (a.k.a tensor values) to		To allow progressive lowering from the value world (a.k.a tensor values) to
the buffer world (a.k.a memref values), a `linalg.generic` op accepts		the buffer world (a.k.a memref values), a `linalg.generic` op accepts
mixing input and output ranked tensor values with input and output memrefs.		mixing input and output ranked tensor values with input and output memrefs.
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines	This may lower to either:
-> ()		-> ()
```		```

or IR resembling:		or IR resembling:
```mlir		```mlir
loop.for %m = %c0 to %M step %c1 {		loop.for %m = %c0 to %M step %c1 {
loop.for %n = %c0 to %N step %c1 {		loop.for %n = %c0 to %N step %c1 {
loop.for %k = %c0 to %K step %c1 {		loop.for %k = %c0 to %K step %c1 {
%a = linalg.load %A[%m, %k] : memref<?x?xf32, stride_specification>		%a = load %A[%m, %k] : memref<?x?xf32, stride_specification>
%b = linalg.load %B[%k, %n] : memref<?x?xf32, stride_specification>		%b = load %B[%k, %n] : memref<?x?xf32, stride_specification>
%c = linalg.load %C[%m, %n] : memref<?x?xf32, stride_specification>		%c = load %C[%m, %n] : memref<?x?xf32, stride_specification>
%d = call @func_of_elements_and_indices(%m, %n, %k, %a, %b, %c)		%d = call @func_of_elements_and_indices(%m, %n, %k, %a, %b, %c)
: (index, index, index, f32, f32, f32) -> (f32)		: (index, index, index, f32, f32, f32) -> (f32)
linalg.store %d, %C[%m, %n] : memref<?x?x?xf32, stride_specification>		store %d, %C[%m, %n] : memref<?x?x?xf32, stride_specification>
}		}
}		}
}		}
```		```

To allow progressive lowering from the value world (a.k.a tensor values) to		To allow progressive lowering from the value world (a.k.a tensor values) to
the buffer world (a.k.a memref values), a `linalg.indexed_generic` op		the buffer world (a.k.a memref values), a `linalg.indexed_generic` op
accepts mixing input and output ranked tensor values with input and output		accepts mixing input and output ranked tensor values with input and output
Show All 31 Lines

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

This file was added.

				//===- LinalgStructuredInterface.td- Linalg StructuredIfce -- tablegen --===//
				//
				// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
				// See https://llvm.org/LICENSE.txt for license information.
				// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
				//
				//===----------------------------------------------------------------------===//
				//
				// This is the definition file for the structured interface for Linalg ops.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LINALG_IR_STRUCTURED_OPS_INTERFACE
				#define LINALG_IR_STRUCTURED_OPS_INTERFACE
				rriddleUnsubmitted Done Reply Inline Actions LINALG_IR_STRUCTURED_OPS_INTERFACE ? rriddle: LINALG_IR_STRUCTURED_OPS_INTERFACE ?
				nicolasvasilacheAuthorUnsubmitted Done Reply Inline Actions thanks! nicolasvasilache: thanks!

				include "mlir/Dialect/Linalg/IR/LinalgBase.td"

				// The linalg 'LinalgStructuredInterface' provides access to the 'LinalgOp'
				// interface.
				def LinalgStructuredInterface : OpInterface<"LinalgOp"> {
				let methods = [
				//===------------------------------------------------------------------===//
				// Loop types handling.
				rriddleUnsubmitted Done Reply Inline Actions Same here. rriddle: Same here.
				//===------------------------------------------------------------------===//
				InterfaceMethod<
				"Return the number of parallel loops within the current operation.",
				"unsigned", "getNumParallelLoops"
				>,
				InterfaceMethod<
				"Return the number of reduction loops within the current operation.",
				"unsigned", "getNumReductionLoops"
				>,
				InterfaceMethod<
				"Return the number of window loops within the current operation.",
				"unsigned", "getNumWindowLoops"
				>,
				InterfaceMethod<
				"Return the number of loops within the current operation.",
				"unsigned", "getNumLoops">,

				InterfaceMethod<
				[{Returns true if the current operation has only one loop and it's a
				reduction loop}],
				"bool", "hasSingleReductionLoop">,

				//===------------------------------------------------------------------===//
				// Input arguments handling.
				//===------------------------------------------------------------------===//
				InterfaceMethod<
				"Return the number of inputs from the current operation.",
				"unsigned", "getNumInputs"
				>,
				InterfaceMethod<"Return the input view at the given index.",
				"Value", "getInput", (ins "unsigned":$i)
				>,
				InterfaceMethod<[{
				Return the index of the given input value `v`, or `None` if the value is
				not an input.
				}],
				"llvm::Optional<unsigned>", "getIndexOfInput", (ins "Value":$v)
				>,
				InterfaceMethod<
				"Return the input operands from the current operation.",
				"Operation::operand_range", "getInputs"
				>,
				InterfaceMethod<[{
				Return the type of the input shape at the given index.
				}], "ShapedType", "getInputShapedType", (ins "unsigned":$i)>,
				InterfaceMethod<[{
				Return the subset of input operands that are of ranked tensor type.
				}], "SmallVector<RankedTensorType, 4>", "getInputTensorTypes">,

				//===------------------------------------------------------------------===//
				// Output arguments handling.
				//===------------------------------------------------------------------===//
				InterfaceMethod<
				"Return the number of outputs from the current operation.",
				"unsigned", "getNumOutputs"
				>,
				InterfaceMethod<"Return the output buffer at the given index.",
				"Value", "getOutputBuffer", (ins "unsigned":$i)
				>,
				InterfaceMethod<[{
				Return the index of the given buffer value, or `None` if the value is
				not part of the output buffers.
				}],
				"llvm::Optional<unsigned>", "getIndexOfOutputBuffer", (ins "Value":$view)
				>,
				InterfaceMethod<[{
				Return the type of the output buffer at the given index.
				}], "MemRefType", "getOutputBufferType", (ins "unsigned":$i)>,
				InterfaceMethod<[{
				Return the results that are of ranked tensor type.
				}], "SmallVector<RankedTensorType, 4>", "getOutputTensorTypes">,
				InterfaceMethod<
				"Return the output buffers (operands) from the current operation.",
				"Operation::operand_range", "getOutputBuffers"
				>,

				//===------------------------------------------------------------------===//
				// Input and Output arguments handling.
				//===------------------------------------------------------------------===//
				InterfaceMethod<
				"Return the number of inputs and outputs, irrespective of their buffer "
				"or tensor type.",
				"unsigned", "getNumInputsAndOutputs"
				>,
				InterfaceMethod<
				"Return the number of inputs, irrespective of their buffer or tensor "
				"type, and output buffers",
				"unsigned", "getNumInputsAndOutputBuffers"
				>,
				InterfaceMethod<
				"Return the range over inputs (irrespective of type) and output buffers.",
				"Operation::operand_range", "getInputsAndOutputBuffers"
				>,

				//===------------------------------------------------------------------===//
				// Other interface methods.
				//===------------------------------------------------------------------===//
				InterfaceMethod<
				"Return the reference iterators for this named op (if any are specied). "
				"These reference iterators are used to specify the default behavior of "
				"the op. Typically this would be a static method but in order to allow "
				"rank-polymorphic ops, this needs to be per object instance. Named ops "
				"must define referenceIterators, even if empty for the 0-D case. "
				"Generic ops on the other hand have a None `referenceIterators`",
				"llvm::Optional<SmallVector<StringRef, 8>>", "referenceIterators"
				>,
				InterfaceMethod<
				"Return the reference indexing maps for this named op (if any are "
				"specified). Typically this would be a static method but in order to "
				"allow rank-polymorphic ops, this needs to be per object instance. Named "
				"ops must define referenceIterators, even if empty for the 0-D case. "
				"Generic ops on the other hand have a None `referenceIndexingMaps`",
				"llvm::Optional<SmallVector<AffineMap, 8>>", "referenceIndexingMaps"
				>,
				InterfaceMethod<
				"Return the iterator types attribute within the current operation.",
				"ArrayAttr", "iterator_types"
				>,
				InterfaceMethod<
				"Return the indexing maps attribute within the current operation.",
				"ArrayAttr", "indexing_maps"
				>,
				InterfaceMethod<"Return the input or output indexing map at index `i`.",
				"AffineMap", "getIndexingMap", (ins "unsigned":$i)
				>,
				InterfaceMethod<"Return the input indexing map at index `i`.",
				"AffineMap", "getInputIndexingMap", (ins "unsigned":$i)
				>,
				InterfaceMethod<"Return the output indexing map at index `i`.",
				"AffineMap", "getOutputIndexingMap", (ins "unsigned":$i)
				>,
				InterfaceMethod<[{
				Return whether the op has only MemRef input and outputs.
				}], "bool", "hasBufferSemantics">,
				InterfaceMethod<[{
				Return whether the op has only RankedTensor input and outputs.
				}], "bool", "hasTensorSemantics">,

				//===------------------------------------------------------------------===//
				// Other static interface methods.
				//===------------------------------------------------------------------===//
				StaticInterfaceMethod<[{
				Create an operation of the current type with the given location,
				operands, and attributes.
				}],
				"Operation *", "create",
				(ins "OpBuilder &":$builder, "Location":$loc,
				"ValueRange":$operands,
				"ArrayRef<NamedAttribute>":$attributes), [{
				return builder.create<ConcreteOp>(loc, ArrayRef<Type>{}, operands,
				attributes);
				}]
				>,
				InterfaceMethod<[{
				Clone the current operation with the given location and operands. This
				is used to abstract away the optional underlying region creation.
				}],
				"Operation *", "clone",
				(ins "OpBuilder &":$b, "Location":$loc, "ValueRange":$operands), [{
				BlockAndValueMapping map;
				unsigned numRegions = op.getOperation()->getNumRegions();
				Operation *res = create(b, loc, operands, op.getAttrs());
				assert(res->getNumRegions() == numRegions && "inconsistent # regions");
				for (unsigned ridx = 0; ridx < numRegions; ++ridx)
				op.getOperation()->getRegion(ridx).cloneInto(
				&res->getRegion(ridx), map);
				return res;
				}]
				>
				];
				}

				#endif // LINALG_IR_STRUCTURED_OPS_INTERFACE

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

Show First 20 Lines • Show All 228 Lines • ▼ Show 20 Lines	ArrayAttr iterator_types() {

// If there is no reference, this must be a generic op.		// If there is no reference, this must be a generic op.
// TODO(ntv): Traits are used to define ops. Split into cpp to avoid		// TODO(ntv): Traits are used to define ops. Split into cpp to avoid
// cyclic dependency.		// cyclic dependency.
auto name = this->getOperation()->getName().getStringRef();		auto name = this->getOperation()->getName().getStringRef();
if (!maybeReferenceIteratorTypes && name != "generic" &&		if (!maybeReferenceIteratorTypes && name != "generic" &&
name != "indexed_generic") {		name != "indexed_generic") {
this->getOperation()->dump();		this->getOperation()->dump();
llvm_unreachable("Op missing ");		llvm_unreachable("Op missing referenceIterators");
}		}

// If we have a reference, build the reference attribute.		// If we have a reference, build the reference attribute and set it in the
		// op before returning.
auto *ctx = this->getOperation()->getContext();		auto *ctx = this->getOperation()->getContext();
auto attrRange = llvm::map_range(*maybeReferenceIteratorTypes,		auto attrRange = llvm::map_range(*maybeReferenceIteratorTypes,
[ctx](StringRef str) -> Attribute {		[ctx](StringRef str) -> Attribute {
return StringAttr::get(str, ctx);		return StringAttr::get(str, ctx);
});		});
auto attr = ArrayAttr::get(llvm::to_vector<4>(attrRange), ctx);		auto attr = ArrayAttr::get(llvm::to_vector<4>(attrRange), ctx);
// TODO(ntv): Need to memoize this. Can't just store as an attribute atm as		// TODO(ntv): Need to memoize this. Can't just store as an attribute atm as
// it will impact parser, printer and tests.		// it will impact parser, printer and tests.
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/IR/CMakeLists.txt

Show All 13 Lines	add_llvm_library(MLIRLinalgOps
intrinsics_gen		intrinsics_gen
)		)

add_dependencies(MLIRLinalgOps		add_dependencies(MLIRLinalgOps

${LIBS}		${LIBS}
MLIRLinalgOpsIncGen		MLIRLinalgOpsIncGen
MLIRLinalgStructuredOpsIncGen		MLIRLinalgStructuredOpsIncGen
		MLIRLinalgStructuredOpsInterfaceIncGen
)		)
target_link_libraries(MLIRLinalgOps ${LIBS})		target_link_libraries(MLIRLinalgOps ${LIBS})

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

Show First 20 Lines • Show All 860 Lines • ▼ Show 20 Lines	static LogicalResult verify(ConvOp op) {
if (auto dilations = op.dilations()) {		if (auto dilations = op.dilations()) {
if (failed(verifyStrideOrDilation(op, dilations->getValue(),		if (failed(verifyStrideOrDilation(op, dilations->getValue(),
/isStride=/false)))		/isStride=/false)))
return failure();		return failure();
}		}
return success();		return success();
}		}

static AffineMap extractOrIdentityMap(Optional<AffineMap> maybeMap,
unsigned rank, MLIRContext *context) {
if (maybeMap)
return maybeMap.getValue();
if (rank == 0)
return AffineMap();
return AffineMap::getMultiDimIdentityMap(rank, context);
}

namespace mlir {		namespace mlir {
namespace linalg {		namespace linalg {

#include "mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterfaces.cpp.inc"		#include "mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterfaces.cpp.inc"

#define GET_OP_CLASSES		#define GET_OP_CLASSES
#include "mlir/Dialect/Linalg/IR/LinalgOps.cpp.inc"		#include "mlir/Dialect/Linalg/IR/LinalgOps.cpp.inc"

#define GET_OP_CLASSES		#define GET_OP_CLASSES
#include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"		#include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"

} // namespace linalg		} // namespace linalg
} // namespace mlir		} // namespace mlir

// Returns `num` AffineDimExpr dimensions at positions [curIdx, curIdx + num)		AffineMap mlir::linalg::extractOrIdentityMap(Optional<AffineMap> maybeMap,
// and increments `curIdx` to `curIdx + num`.		unsigned rank,
static SmallVector<AffineExpr, 4>		MLIRContext *context) {
makeAffineDimExprs(unsigned num, unsigned &curIdx, MLIRContext *context) {		if (maybeMap)
		return maybeMap.getValue();
		if (rank == 0)
		return AffineMap();
		return AffineMap::getMultiDimIdentityMap(rank, context);
		}

		SmallVector<AffineExpr, 4>
		mlir::linalg::makeAffineDimExprs(unsigned num, unsigned &startIdx,
		MLIRContext *context) {
SmallVector<AffineExpr, 4> res;		SmallVector<AffineExpr, 4> res;
res.reserve(num);		res.reserve(num);
for (unsigned i = 0; i < num; ++i)		for (unsigned i = 0; i < num; ++i)
res.push_back(getAffineDimExpr(curIdx++, context));		res.push_back(getAffineDimExpr(startIdx++, context));
return res;		return res;
}		}

static SmallVector<AffineExpr, 4>		SmallVector<AffineExpr, 4>
weightedConvInputIndex(ConvOp op, ArrayRef<AffineExpr> a,		mlir::linalg::weightedConvInputIndex(ConvOp op, ArrayRef<AffineExpr> xs,
ArrayRef<AffineExpr> b) {		ArrayRef<AffineExpr> zs) {
assert(a.size() == b.size());		assert(xs.size() == zs.size());
		rriddleUnsubmitted Done Reply Inline Actions Was there a problem with using llvm::concat? rriddle: Was there a problem with using llvm::concat?
		nicolasvasilacheAuthorUnsubmitted Done Reply Inline Actions This SmallVector<AffineExpr, 4> mlir::linalg::concat(ArrayRef<AffineExpr> a, ArrayRef<AffineExpr> b) { auto rangeA = llvm::make_range(a.begin(), a.end()); auto rangeB = llvm::make_range(b.begin(), b.end()); auto concatRanges = llvm::concat<AffineExpr>(rangeA, rangeB); return llvm::to_vector<4>(concatRanges); } fails with ERROR: third_party/llvm/llvm-project/llvm/include/llvm/ADT/STLExtras.h:855:12 cannot initialize return object of type 'mlir::AffineExpr ' with an rvalue of type 'const mlir::AffineExpr ' return &Begin; ^~~~~~~ third_party/llvm/llvm-project/llvm/include/llvm/ADT/STLExtras.h:865:27 in instantiation of function template specialization 'llvm::concat_iterator<mlir::AffineExpr, const mlir::AffineExpr , const mlir::AffineExpr >::getHelper<1>' requested here &concat_iterator::getHelper<Ns>...}; ^ third_party/llvm/llvm-project/llvm/include/llvm/ADT/STLExtras.h:892:12 in instantiation of function template specialization 'llvm::concat_iterator<mlir::AffineExpr, const mlir::AffineExpr , const mlir::AffineExpr >::get<0, 1>' requested here return get(std::index_sequence_for<IterTs...>()); ^ third_party/crosstool/v18/stable/toolchain/include/c++/v1/memory:3162:75 in instantiation of member function 'llvm::concat_iterator<mlir::AffineExpr, const mlir::AffineExpr , const mlir::AffineExpr >::operator' requested here ::new (static_cast<void>(_VSTD::addressof(__r))) value_type(__f); ^ third_party/llvm/llvm-project/llvm/include/llvm/ADT/SmallVector.h:279:10 in instantiation of function template specialization 'std::__u::uninitialized_copy<llvm::concat_iterator<mlir::AffineExpr, const mlir::AffineExpr , const mlir::AffineExpr >, mlir::AffineExpr >' requested here std::uninitialized_copy(I, E, Dest); ^ third_party/llvm/llvm-project/llvm/include/llvm/ADT/SmallVector.h:392:11 in instantiation of function template specialization 'llvm::SmallVectorTemplateBase<mlir::AffineExpr, true>::uninitialized_copy<llvm::concat_iterator<mlir::AffineExpr, const mlir::AffineExpr , const mlir::AffineExpr >, mlir::AffineExpr >' requested here this->uninitialized_copy(in_start, in_end, this->end()); ^ third_party/llvm/llvm-project/llvm/include/llvm/ADT/SmallVector.h:856:11 in instantiation of function template specialization 'llvm::SmallVectorImpl<mlir::AffineExpr>::append<llvm::concat_iterator<mlir::AffineExpr, const mlir::AffineExpr , const mlir::AffineExpr >, void>' requested here this->append(S, E); ^ third_party/llvm/llvm-project/llvm/include/llvm/ADT/SmallVector.h:918:10 in instantiation of function template specialization 'llvm::SmallVector<mlir::AffineExpr, 4>::SmallVector<llvm::concat_iterator<mlir::AffineExpr, const mlir::AffineExpr , const mlir::AffineExpr >, void>' requested here return {std::begin(Range), std::end(Range)}; ^ third_party/llvm/llvm-project/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp:919:16 in instantiation of function template specialization 'llvm::to_vector<4, llvm::detail::concat_range<mlir::AffineExpr, llvm::iterator_range<const mlir::AffineExpr > &, llvm::iterator_range<const mlir::AffineExpr > &> &>' requested here return llvm::to_vector<4>(concatRanges); What am I missing? nicolasvasilache:* This ``` SmallVector<AffineExpr, 4> mlir::linalg::concat(ArrayRef<AffineExpr> a…
		rriddleUnsubmitted Done Reply Inline Actions I think you would need to do `llvm::concat<const AffineExpr>(...)`, given that ArrayRef holds values of `const T`. rriddle: I think you would need to do `llvm::concat<const AffineExpr>(...)`, given that ArrayRef holds…
		nicolasvasilacheAuthorUnsubmitted Done Reply Inline Actions well .. of course, thanks! nicolasvasilache: well .. of course, thanks!
SmallVector<AffineExpr, 4> res;		SmallVector<AffineExpr, 4> res;
res.reserve(a.size());		res.reserve(xs.size());
for (unsigned i = 0, e = a.size(); i < e; ++i) {		for (unsigned i = 0, e = xs.size(); i < e; ++i)
res.push_back(op.getStride(i) * a[i] + op.getDilation(i) * b[i]);		res.push_back(op.getStride(i) * xs[i] + op.getDilation(i) * zs[i]);
}
return res;		return res;
}		}

static SmallVector<AffineExpr, 4> concat(ArrayRef<AffineExpr> a,		SmallVector<AffineExpr, 4> mlir::linalg::concat(ArrayRef<AffineExpr> a,
ArrayRef<AffineExpr> b) {		ArrayRef<AffineExpr> b) {
SmallVector<AffineExpr, 4> res;		auto rangeA = llvm::make_range(a.begin(), a.end());
res.reserve(a.size() + b.size());		auto rangeB = llvm::make_range(b.begin(), b.end());
res.assign(a.begin(), a.end());		auto concatRanges = llvm::concat<const AffineExpr>(rangeA, rangeB);
res.append(b.begin(), b.end());		return llvm::to_vector<4>(concatRanges);
return res;
}

// Note: both functions below would completely disappear with a simple tensor
// kernel language.
//
// Ideally this should all be Tablegen'd but there is no good story for
// AffineMap for now.
SmallVector<AffineMap, 4> mlir::linalg::loopToOperandRangesMaps(Operation *op) {
MLIRContext *context = op->getContext();
if (auto copyOp = dyn_cast<CopyOp>(op)) {
// I(input_perm(ivs)) -> O(output_perm(ivs))
auto maybeInputMap = copyOp.inputPermutation();
auto maybeOutputMap = copyOp.outputPermutation();
unsigned inputRank = copyOp.getInputShapedType(0).getRank();
unsigned outputRank = copyOp.getOutputShapedType(0).getRank();
return SmallVector<AffineMap, 4>{
extractOrIdentityMap(maybeInputMap, inputRank, context),
extractOrIdentityMap(maybeOutputMap, outputRank, context)};
}
if (auto fillOp = dyn_cast<FillOp>(op)) {
// filling_value -> O(ivs)
unsigned rank = fillOp.getNumParallelLoops();
return SmallVector<AffineMap, 4>{
extractOrIdentityMap(llvm::None, rank, context)};
}
auto i = getAffineDimExpr(0, context);
auto j = getAffineDimExpr(1, context);
auto k = getAffineDimExpr(2, context);
if (isa<DotOp>(op))
// A(r_i) * B(r_i) -> C()
return SmallVector<AffineMap, 4>{AffineMap::get(1, 0, {i}),
AffineMap::get(1, 0, {i}), AffineMap()};
if (isa<MatvecOp>(op))
// A(i, r_j) * B(r_j) -> C(i)
return SmallVector<AffineMap, 4>{AffineMap::get(2, 0, {i, j}),
AffineMap::get(2, 0, {j}),
AffineMap::get(2, 0, {i})};
if (isa<MatmulOp>(op))
// A(i, r_k) * B(r_k, j) -> C(i, j)
return SmallVector<AffineMap, 4>{AffineMap::get(3, 0, {i, k}),
AffineMap::get(3, 0, {k, j}),
AffineMap::get(3, 0, {i, j})};
if (auto convOp = dyn_cast<ConvOp>(op)) {
// F(z0, ..., zN-1, q, k) * I(b, x0 + z0, ..., xN-1 + zN-1, q) ->
// O(b, x0, ..., xN-1, k)
// for N equal to `nWindow`.
auto nWin = convOp.getNumWindowLoops();
assert(nWin > 0 && "expected at least one window dimension");
unsigned idx = 0;
// In the following, AffineDimExprs are indexed in loop order:
// [ b, xs, k, q, zs]
// parallels non-window reductions windows
//
// Parallel dims are exactly the dimensions indexing `output`:
// output[b, x[0], ..., x[N-1], k]; i.e.
// * batch dimensions (bs with #bs = 1 for now)
// * "image" dimensions (xs with #xs = #zs = output_rank - #bs - #ks)
// * output filter dimensions (ks with #ks = 1 for now)
auto bs = makeAffineDimExprs(convOp.getNumBatchDimensions(), idx, context);
auto xs = makeAffineDimExprs(nWin, idx, context);
auto ks = makeAffineDimExprs(convOp.getNumOutputFeatureDimensions(), idx,
context);
// Non-window reduction dim: sum_{z[0], ..., z[N-1], q}
auto qs =
makeAffineDimExprs(convOp.getNumInputFeatureDimensions(), idx, context);
// Window reduction dims: sum_{z[0], ..., z[N-1], q}
auto zs = makeAffineDimExprs(nWin, idx, context);
// Construct the weighedSum expression.
auto ws = weightedConvInputIndex(convOp, xs, zs);
return SmallVector<AffineMap, 4>{
// filter[z[0], ..., z[N-1], q, k]
AffineMap::get(idx, 0, concat(concat(zs, qs), ks)),
// input[b,
// x[0]s[0] + d[0]z[0], ..., x[N-1]s[N-1] + d[N-1]z[N-1],
// q]
AffineMap::get(idx, 0, concat(concat(bs, ws), qs)),
// output[b, x[0], ..., x[N-1], k]
AffineMap::get(idx, 0, concat(concat(bs, xs), ks))};
}
SmallVector<AffineMap, 4> res;
auto linalgOp = cast<LinalgOp>(op);
unsigned nViews = linalgOp.getNumInputsAndOutputs();
res.reserve(nViews);
for (unsigned i = 0, e = nViews; i < e; ++i)
res.push_back(linalgOp.getIndexingMap(i));
assert(nViews == linalgOp.indexing_maps().size());
return res;
}		}

static void appendMangledType(llvm::raw_string_ostream &ss, Type t) {		static void appendMangledType(llvm::raw_string_ostream &ss, Type t) {
if (auto memref = t.dyn_cast<MemRefType>()) {		if (auto memref = t.dyn_cast<MemRefType>()) {
ss << "view";		ss << "view";
for (auto size : memref.getShape())		for (auto size : memref.getShape())
if (size < 0)		if (size < 0)
ss << "sx";		ss << "sx";
Show All 21 Lines	std::string mlir::linalg::generateLibraryCallName(Operation *op) {
ss << "_";		ss << "_";
auto types = op->getOperandTypes();		auto types = op->getOperandTypes();
interleave(		interleave(
types.begin(), types.end(), [&](Type t) { appendMangledType(ss, t); },		types.begin(), types.end(), [&](Type t) { appendMangledType(ss, t); },
[&]() { ss << "_"; });		[&]() { ss << "_"; });
return ss.str();		return ss.str();
}		}

static ArrayAttr getIndexingMaps(Operation *op) {
LinalgOp linalgOp = cast<LinalgOp>(op);
SmallVector<Attribute, 4> maps;
maps.reserve(linalgOp.getNumInputsAndOutputs());
for (AffineMap map : loopToOperandRangesMaps(op))
maps.push_back(AffineMapAttr::get(map));
return ArrayAttr::get(maps, op->getContext());
}
ArrayAttr mlir::linalg::ConvOp::indexing_maps() {
return getIndexingMaps(getOperation());
}
ArrayAttr mlir::linalg::CopyOp::indexing_maps() {
return getIndexingMaps(getOperation());
}
ArrayAttr mlir::linalg::DotOp::indexing_maps() {
return getIndexingMaps(getOperation());
}
ArrayAttr mlir::linalg::FillOp::indexing_maps() {
return getIndexingMaps(getOperation());
}
ArrayAttr mlir::linalg::MatmulOp::indexing_maps() {
return getIndexingMaps(getOperation());
}
ArrayAttr mlir::linalg::MatvecOp::indexing_maps() {
return getIndexingMaps(getOperation());
}

// TODO(ntv, rriddle): Consider making all this boilerplate easy to autogenerate		// TODO(ntv, rriddle): Consider making all this boilerplate easy to autogenerate
// with Tablegen. This seems a desirable property in the context of OpInterfaces		// with Tablegen. This seems a desirable property in the context of OpInterfaces
// where a Linalg "named" op isa LinalgOp.		// where a Linalg "named" op isa LinalgOp.
LogicalResult ConvOp::fold(ArrayRef<Attribute>,		LogicalResult ConvOp::fold(ArrayRef<Attribute>,
SmallVectorImpl<OpFoldResult> &) {		SmallVectorImpl<OpFoldResult> &) {
return foldMemRefCast(*this);		return foldMemRefCast(*this);
}		}
LogicalResult CopyOp::fold(ArrayRef<Attribute>,		LogicalResult CopyOp::fold(ArrayRef<Attribute>,
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines

// Return a cloned version of `op` that operates on `loopRanges`, assumed to be		// Return a cloned version of `op` that operates on `loopRanges`, assumed to be
// a subset of the original loop ranges of `op`.		// a subset of the original loop ranges of `op`.
// This is achieved by applying the `loopToOperandRangesMaps` permutation maps		// This is achieved by applying the `loopToOperandRangesMaps` permutation maps
// to the `loopRanges` in order to obtain view ranges.		// to the `loopRanges` in order to obtain view ranges.
static LinalgOp cloneWithLoopRanges(OpBuilder &b, Location loc, LinalgOp op,		static LinalgOp cloneWithLoopRanges(OpBuilder &b, Location loc, LinalgOp op,
ArrayRef<SubViewOp::Range> loopRanges) {		ArrayRef<SubViewOp::Range> loopRanges) {
assert(op.hasBufferSemantics() && "expected linalg op with buffer semantics");		assert(op.hasBufferSemantics() && "expected linalg op with buffer semantics");
auto maps = loopToOperandRangesMaps(op);		auto maps = op.indexing_maps();
SmallVector<Value, 8> clonedViews;		SmallVector<Value, 8> clonedViews;
clonedViews.reserve(op.getNumInputsAndOutputs());		clonedViews.reserve(op.getNumInputsAndOutputs());
// Iterate over the inputs and outputs in order.		// Iterate over the inputs and outputs in order.
// Extract the subranges from the linearized ranges.		// Extract the subranges from the linearized ranges.
SmallVector<Value, 8> ios(op.getInputsAndOutputBuffers());		SmallVector<Value, 8> ios(op.getInputsAndOutputBuffers());
for (auto en : llvm::enumerate(ios)) {		for (auto en : llvm::enumerate(ios)) {
unsigned idx = en.index();		unsigned idx = en.index();
auto map = maps[idx];		auto map = maps[idx].cast<AffineMapAttr>().getValue();
LLVM_DEBUG(dbgs() << "map: " << map << "\n");		LLVM_DEBUG(dbgs() << "map: " << map << "\n");
Value view = en.value();		Value view = en.value();
SmallVector<SubViewOp::Range, 4> viewRanges(map.getNumResults());		SmallVector<SubViewOp::Range, 4> viewRanges(map.getNumResults());
for (auto en2 : llvm::enumerate(map.getResults())) {		for (auto en2 : llvm::enumerate(map.getResults())) {
unsigned d = en2.index();		unsigned d = en2.index();
// loopToOperandRangesMaps are permutations-only.		// loopToOperandRangesMaps are permutations-only.
unsigned loopPos = en2.value().cast<AffineDimExpr>().getPosition();		unsigned loopPos = en2.value().cast<AffineDimExpr>().getPosition();
viewRanges[d] = loopRanges[loopPos];		viewRanges[d] = loopRanges[loopPos];
Show All 27 Lines

// Given an `op`, returns the first (`view`, `dimension`) pair that identifies		// Given an `op`, returns the first (`view`, `dimension`) pair that identifies
// the loop range at `loopDepth`. The semantics of the loopToOperandRangesMaps		// the loop range at `loopDepth`. The semantics of the loopToOperandRangesMaps
// guarantees at least one such dimension is found. If multiple candidates exist		// guarantees at least one such dimension is found. If multiple candidates exist
// they must agree by construction (i.e. have the same size) and we just return		// they must agree by construction (i.e. have the same size) and we just return
// the first one.		// the first one.
static ViewDimension getViewDefiningLoopRange(LinalgOp op, unsigned loopDepth) {		static ViewDimension getViewDefiningLoopRange(LinalgOp op, unsigned loopDepth) {
assert(op.hasBufferSemantics() && "expected linalg op with buffer semantics");		assert(op.hasBufferSemantics() && "expected linalg op with buffer semantics");
auto maps = loopToOperandRangesMaps(op);		auto maps = op.indexing_maps();
// Iterate over the inputs and outputs in order.		// Iterate over the inputs and outputs in order.
// Extract the subranges from the linearized ranges.		// Extract the subranges from the linearized ranges.
SmallVector<Value, 8> ios(op.getInputsAndOutputBuffers());		SmallVector<Value, 8> ios(op.getInputsAndOutputBuffers());
for (auto en : llvm::enumerate(ios)) {		for (auto en : llvm::enumerate(ios)) {
unsigned idx = en.index();		unsigned idx = en.index();
auto map = maps[idx];		auto map = maps[idx].cast<AffineMapAttr>().getValue();
LLVM_DEBUG(dbgs() << "getViewDefiningLoopRange I/O idx: " << idx << "\n");		LLVM_DEBUG(dbgs() << "getViewDefiningLoopRange I/O idx: " << idx << "\n");
LLVM_DEBUG(dbgs() << "getViewDefiningLoopRange map: " << map << "\n");		LLVM_DEBUG(dbgs() << "getViewDefiningLoopRange map: " << map << "\n");
Value view = en.value();		Value view = en.value();
SmallVector<Value, 8> viewRanges(map.getNumResults(), nullptr);		SmallVector<Value, 8> viewRanges(map.getNumResults(), nullptr);
for (auto en2 : llvm::enumerate(map.getResults())) {		for (auto en2 : llvm::enumerate(map.getResults())) {
if (loopDepth == en2.value().cast<AffineDimExpr>().getPosition()) {		if (loopDepth == en2.value().cast<AffineDimExpr>().getPosition()) {
LLVM_DEBUG(dbgs() << "getViewDefiningLoopRange loopDepth: " << loopDepth		LLVM_DEBUG(dbgs() << "getViewDefiningLoopRange loopDepth: " << loopDepth
<< "\n");		<< "\n");
Show All 19 Lines	static LinalgOp fuse(Value producedView, LinalgOp producer, LinalgOp consumer,
assert(subView \|\| slice);		assert(subView \|\| slice);
(void)subView;		(void)subView;
(void)slice;		(void)slice;

// loopToOperandRangesMaps are permutations-only by construction:		// loopToOperandRangesMaps are permutations-only by construction:
// we can always identify a data dimension with a (at least one) loop		// we can always identify a data dimension with a (at least one) loop
// dimension.		// dimension.
AffineMap producerMap =		AffineMap producerMap =
loopToOperandRangesMaps(producer)[producer.getNumInputs() + producerIdx];		producer.indexing_maps()[producer.getNumInputs() + producerIdx]
		.cast<AffineMapAttr>()
		.getValue();
LLVM_DEBUG(dbgs() << "Producer Idx: " << producerIdx		LLVM_DEBUG(dbgs() << "Producer Idx: " << producerIdx
<< ", producer map: " << producerMap << "\n");		<< ", producer map: " << producerMap << "\n");

unsigned nPar = producer.getNumParallelLoops();		unsigned nPar = producer.getNumParallelLoops();
unsigned nRed = producer.getNumReductionLoops();		unsigned nRed = producer.getNumReductionLoops();
unsigned nWin = producer.getNumWindowLoops();		unsigned nWin = producer.getNumWindowLoops();
SmallVector<SubViewOp::Range, 8> loopRanges(nPar + nRed + nWin);		SmallVector<SubViewOp::Range, 8> loopRanges(nPar + nRed + nWin);

Show All 10 Lines	static LinalgOp fuse(Value producedView, LinalgOp producer, LinalgOp consumer,
// producer map for `producerIdx`, we need to explicitly compute the view that		// producer map for `producerIdx`, we need to explicitly compute the view that
// defines the loop ranges using the `producer`.		// defines the loop ranges using the `producer`.
for (unsigned i = 0, nLoops = loopRanges.size(); i < nLoops; ++i) {		for (unsigned i = 0, nLoops = loopRanges.size(); i < nLoops; ++i) {
if (loopRanges[i].offset)		if (loopRanges[i].offset)
LLVM_DEBUG(llvm::dbgs()		LLVM_DEBUG(llvm::dbgs()
<< "existing LoopRange: " << loopRanges[i] << "\n");		<< "existing LoopRange: " << loopRanges[i] << "\n");
else {		else {
auto viewDim = getViewDefiningLoopRange(producer, i);		auto viewDim = getViewDefiningLoopRange(producer, i);
loopRanges[i] = SubViewOp::Range{		loopRanges[i] = SubViewOp::Range{folded_std_constant_index(folder, 0),
folded_std_constant_index(folder, 0),
std_dim(viewDim.view, viewDim.dimension),		std_dim(viewDim.view, viewDim.dimension),
folded_std_constant_index(folder, 1)		folded_std_constant_index(folder, 1)};
};
LLVM_DEBUG(llvm::dbgs() << "new LoopRange: " << loopRanges[i] << "\n");		LLVM_DEBUG(llvm::dbgs() << "new LoopRange: " << loopRanges[i] << "\n");
}		}
}		}

return cloneWithLoopRanges(b, loc, producer, loopRanges);		return cloneWithLoopRanges(b, loc, producer, loopRanges);
}		}

// Encode structural fusion safety preconditions.		// Encode structural fusion safety preconditions.
▲ Show 20 Lines • Show All 366 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

Show All 14 Lines
#include "mlir/Dialect/Linalg/Utils/Utils.h"		#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/LoopOps/EDSC/Builders.h"		#include "mlir/Dialect/LoopOps/EDSC/Builders.h"
#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"		#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
#include "mlir/IR/AffineExpr.h"		#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"		#include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h"		#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/OpImplementation.h"		#include "mlir/IR/OpImplementation.h"
#include "mlir/Pass/Pass.h"		#include "mlir/Pass/Pass.h"
		#include "mlir/Support/Functional.h"
#include "mlir/Support/LLVM.h"		#include "mlir/Support/LLVM.h"
#include "mlir/Support/STLExtras.h"		#include "mlir/Support/STLExtras.h"
#include "mlir/Transforms/DialectConversion.h"		#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/FoldUtils.h"		#include "mlir/Transforms/FoldUtils.h"

using namespace mlir;		using namespace mlir;
using namespace mlir::edsc;		using namespace mlir::edsc;
using namespace mlir::edsc::intrinsics;		using namespace mlir::edsc::intrinsics;
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Lines
template <typename IndexedValueType>		template <typename IndexedValueType>
class LinalgScopedEmitter<IndexedValueType, ConvOp> {		class LinalgScopedEmitter<IndexedValueType, ConvOp> {
public:		public:
static void emitScalarImplementation(ArrayRef<Value> allIvs, ConvOp convOp) {		static void emitScalarImplementation(ArrayRef<Value> allIvs, ConvOp convOp) {
assert(convOp.hasBufferSemantics() &&		assert(convOp.hasBufferSemantics() &&
"expected linalg op with buffer semantics");		"expected linalg op with buffer semantics");
auto b = ScopedContext::getBuilder();		auto b = ScopedContext::getBuilder();
auto loc = ScopedContext::getLocation();		auto loc = ScopedContext::getLocation();
auto maps = loopToOperandRangesMaps(convOp);		auto mapsRange = convOp.indexing_maps().getAsRange<AffineMapAttr>();
		auto maps = functional::map([](AffineMapAttr a) { return a.getValue(); },
		mapsRange);
SmallVector<ValueHandle, 8> fIdx(		SmallVector<ValueHandle, 8> fIdx(
makeCanonicalAffineApplies(b, loc, maps[0], allIvs));		makeCanonicalAffineApplies(b, loc, maps[0], allIvs));
SmallVector<ValueHandle, 8> imIdx(		SmallVector<ValueHandle, 8> imIdx(
makeCanonicalAffineApplies(b, loc, maps[1], allIvs));		makeCanonicalAffineApplies(b, loc, maps[1], allIvs));
SmallVector<ValueHandle, 8> oIdx(		SmallVector<ValueHandle, 8> oIdx(
makeCanonicalAffineApplies(b, loc, maps[2], allIvs));		makeCanonicalAffineApplies(b, loc, maps[2], allIvs));
IndexedValueType F(convOp.filter()), I(convOp.input()), O(convOp.output());		IndexedValueType F(convOp.filter()), I(convOp.input()), O(convOp.output());
// Emit scalar form.		// Emit scalar form.
▲ Show 20 Lines • Show All 243 Lines • ▼ Show 20 Lines	LogicalResult LinalgOpToLoopsImpl<LoopTy, IndexedValueTy, ConcreteOpTy>::doit(
assert(linalgOp.hasBufferSemantics() &&		assert(linalgOp.hasBufferSemantics() &&
"expected linalg op with buffer semantics");		"expected linalg op with buffer semantics");
auto nPar = linalgOp.getNumParallelLoops();		auto nPar = linalgOp.getNumParallelLoops();
auto nRed = linalgOp.getNumReductionLoops();		auto nRed = linalgOp.getNumReductionLoops();
auto nWin = linalgOp.getNumWindowLoops();		auto nWin = linalgOp.getNumWindowLoops();
auto nLoops = nPar + nRed + nWin;		auto nLoops = nPar + nRed + nWin;
if (!loweringIsAllowed<LoopTy>(nPar, nLoops))		if (!loweringIsAllowed<LoopTy>(nPar, nLoops))
return failure();		return failure();
auto invertedMap =		auto mapsRange =
inversePermutation(concatAffineMaps(loopToOperandRangesMaps(linalgOp)));		linalgOp.indexing_maps().template getAsRange<AffineMapAttr>();
		auto maps =
		functional::map([](AffineMapAttr a) { return a.getValue(); }, mapsRange);
		auto invertedMap = inversePermutation(concatAffineMaps(maps));
if (!invertedMap) {		if (!invertedMap) {
LinalgScopedEmitter<IndexedValueTy, ConcreteOpTy>::emitScalarImplementation(		LinalgScopedEmitter<IndexedValueTy, ConcreteOpTy>::emitScalarImplementation(
{}, linalgOp);		{}, linalgOp);
return success();		return success();
}		}

SmallVector<ValueHandle, 4> allIvs(nLoops, ValueHandle(b.getIndexType()));		SmallVector<ValueHandle, 4> allIvs(nLoops, ValueHandle(b.getIndexType()));
SmallVector<ValueHandle *, 4> allPIvs =		SmallVector<ValueHandle *, 4> allPIvs =
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

Show All 16 Lines
#include "mlir/Dialect/Linalg/Utils/Utils.h"		#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/LoopOps/EDSC/Builders.h"		#include "mlir/Dialect/LoopOps/EDSC/Builders.h"
#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"		#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
#include "mlir/IR/AffineExpr.h"		#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineExprVisitor.h"		#include "mlir/IR/AffineExprVisitor.h"
#include "mlir/IR/AffineMap.h"		#include "mlir/IR/AffineMap.h"
#include "mlir/IR/OpImplementation.h"		#include "mlir/IR/OpImplementation.h"
#include "mlir/Pass/Pass.h"		#include "mlir/Pass/Pass.h"
		#include "mlir/Support/Functional.h"
#include "mlir/Support/LLVM.h"		#include "mlir/Support/LLVM.h"
#include "mlir/Support/STLExtras.h"		#include "mlir/Support/STLExtras.h"
#include "mlir/Transforms/FoldUtils.h"		#include "mlir/Transforms/FoldUtils.h"

#include "llvm/Support/CommandLine.h"		#include "llvm/Support/CommandLine.h"

using namespace mlir;		using namespace mlir;
using namespace mlir::edsc;		using namespace mlir::edsc;
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines	makeTiledViews(OpBuilder &b, Location loc, LinalgOp linalgOp,
SmallVector<Value, 4> res;		SmallVector<Value, 4> res;
res.reserve(op->getNumOperands());		res.reserve(op->getNumOperands());
auto viewIteratorBegin = linalgOp.getInputsAndOutputBuffers().begin();		auto viewIteratorBegin = linalgOp.getInputsAndOutputBuffers().begin();
for (unsigned viewIndex = 0; viewIndex < linalgOp.getNumInputsAndOutputs();		for (unsigned viewIndex = 0; viewIndex < linalgOp.getNumInputsAndOutputs();
++viewIndex) {		++viewIndex) {
Value view = *(viewIteratorBegin + viewIndex);		Value view = *(viewIteratorBegin + viewIndex);
auto viewType = view.getType().cast<MemRefType>();		auto viewType = view.getType().cast<MemRefType>();
unsigned rank = viewType.getRank();		unsigned rank = viewType.getRank();
auto map = loopToOperandRangesMaps(linalgOp)[viewIndex];		auto mapAttr = linalgOp.indexing_maps()[viewIndex];
		auto map = mapAttr.cast<AffineMapAttr>().getValue();
// If the view is not tiled, we can use it as is.		// If the view is not tiled, we can use it as is.
if (!isTiled(map, tileSizes)) {		if (!isTiled(map, tileSizes)) {
res.push_back(view);		res.push_back(view);
continue;		continue;
}		}

// Construct a new subview for the tile.		// Construct a new subview for the tile.
SmallVector<Value, 4> offsets, sizes, strides;		SmallVector<Value, 4> offsets, sizes, strides;
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines	Optional<TiledLinalgOp> static tileLinalgOpImpl(OpBuilder &b, LinalgOp op,

OpBuilder::InsertionGuard g(b);		OpBuilder::InsertionGuard g(b);
b.setInsertionPoint(op);		b.setInsertionPoint(op);
ScopedContext scope(b, op.getLoc());		ScopedContext scope(b, op.getLoc());
// 2. Build the tiled loop ranges.		// 2. Build the tiled loop ranges.
auto viewSizes = getViewSizes(b, op);		auto viewSizes = getViewSizes(b, op);
// The flattened loopToOperandRangesMaps is expected to be an invertible		// The flattened loopToOperandRangesMaps is expected to be an invertible
// permutation map (asserted in the inverse calculation).		// permutation map (asserted in the inverse calculation).
auto viewSizesToLoopsMap =		auto mapsRange = op.indexing_maps().getAsRange<AffineMapAttr>();
inversePermutation(concatAffineMaps(loopToOperandRangesMaps(op)));		auto maps =
		functional::map([](AffineMapAttr a) { return a.getValue(); }, mapsRange);
		auto viewSizesToLoopsMap = inversePermutation(concatAffineMaps(maps));
assert(viewSizesToLoopsMap && "expected invertible map");		assert(viewSizesToLoopsMap && "expected invertible map");

SmallVector<SubViewOp::Range, 4> loopRanges;		SmallVector<SubViewOp::Range, 4> loopRanges;
LoopIndexToRangeIndexMap loopIndexToRangeIndex;		LoopIndexToRangeIndexMap loopIndexToRangeIndex;
std::tie(loopRanges, loopIndexToRangeIndex) =		std::tie(loopRanges, loopIndexToRangeIndex) =
makeTiledLoopRanges(b, scope.getLocation(), viewSizesToLoopsMap,		makeTiledLoopRanges(b, scope.getLocation(), viewSizesToLoopsMap,
viewSizes, tileSizes, folder);		viewSizes, tileSizes, folder);
if (!permutation.empty())		if (!permutation.empty())
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[mlir][Linalg] NFC - Refactor LinalgStructuredOps towards "named" Linalg ops
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 246697

mlir/include/mlir/Dialect/Linalg/IR/CMakeLists.txt

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.h

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

mlir/lib/Dialect/Linalg/IR/CMakeLists.txt

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

This is an archive of the discontinued LLVM Phabricator instance.

[mlir][Linalg] NFC - Refactor LinalgStructuredOps towards "named" Linalg opsClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 246697

mlir/include/mlir/Dialect/Linalg/IR/CMakeLists.txt

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.h

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

mlir/lib/Dialect/Linalg/IR/CMakeLists.txt

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

[mlir][Linalg] NFC - Refactor LinalgStructuredOps towards "named" Linalg ops
ClosedPublic