26 namespace sparse_tensor {
29 template <
typename ConcreteModel,
typename ConcreteOp>
30 struct SparseBufferizableOpInterfaceExternalModel
31 :
public BufferizableOpInterface::ExternalModel<ConcreteModel, ConcreteOp> {
32 LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
35 "sparse_tensor ops must be bufferized with the sparsifier");
39 struct ConcatenateOpInterface
40 : SparseBufferizableOpInterfaceExternalModel<ConcatenateOpInterface,
41 sparse_tensor::ConcatenateOp> {
42 bool bufferizesToAllocation(Operation *op, Value value)
const {
return true; }
44 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
49 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
59 bool isWritable(Operation *op, Value value,
65 struct ConvertOpInterface :
public SparseBufferizableOpInterfaceExternalModel<
66 ConvertOpInterface, sparse_tensor::ConvertOp> {
67 bool bufferizesToAllocation(Operation *op, Value value)
const {
73 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
78 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
88 bool isWritable(Operation *op, Value value,
94 struct LoadOpInterface
95 :
public SparseBufferizableOpInterfaceExternalModel<LoadOpInterface,
96 sparse_tensor::LoadOp> {
97 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
102 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
113 struct NewOpInterface
114 :
public SparseBufferizableOpInterfaceExternalModel<NewOpInterface,
115 sparse_tensor::NewOp> {
116 bool resultBufferizesToMemoryWrite(Operation *op, OpResult opResult,
122 bool bufferizesToAllocation(Operation *op, Value value)
const {
return true; }
125 struct AssembleOpInterface
126 :
public SparseBufferizableOpInterfaceExternalModel<
127 AssembleOpInterface, sparse_tensor::AssembleOp> {
128 bool bufferizesToAllocation(Operation *op, Value value)
const {
133 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
138 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
145 assert(op->getNumResults() == 1);
157 struct DisassembleOpInterface
158 :
public SparseBufferizableOpInterfaceExternalModel<
159 DisassembleOpInterface, sparse_tensor::DisassembleOp> {
160 bool bufferizesToAllocation(Operation *op, Value value)
const {
165 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
168 return opOperand.getOperandNumber() == 0;
171 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
174 assert(2 * (op->getNumOperands() - 1) == op->getNumResults());
175 return opOperand.getOperandNumber() > 0;
180 assert(2 * (op->getNumOperands() - 1) == op->getNumResults());
182 if (opOperand.getOperandNumber() == 0)
185 return {{op->getResult(opOperand.getOperandNumber() - 1),
190 struct InsertOpInterface :
public SparseBufferizableOpInterfaceExternalModel<
191 InsertOpInterface, sparse_tensor::InsertOp> {
192 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
197 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
206 assert(op->getNumResults() == 1);
211 struct NumberOfEntriesOpInterface
212 :
public SparseBufferizableOpInterfaceExternalModel<
213 NumberOfEntriesOpInterface, sparse_tensor::NumberOfEntriesOp> {
214 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
219 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
230 struct ToCoordinatesBufferOpInterface
231 :
public SparseBufferizableOpInterfaceExternalModel<
232 ToCoordinatesBufferOpInterface,
233 sparse_tensor::ToCoordinatesBufferOp> {
234 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
239 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
252 struct ToCoordinatesOpInterface
253 :
public SparseBufferizableOpInterfaceExternalModel<
254 ToCoordinatesOpInterface, sparse_tensor::ToCoordinatesOp> {
255 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
260 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
273 struct ToPositionsOpInterface
274 :
public SparseBufferizableOpInterfaceExternalModel<
275 ToPositionsOpInterface, sparse_tensor::ToPositionsOp> {
276 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
281 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
294 struct ToValuesOpInterface
295 :
public SparseBufferizableOpInterfaceExternalModel<
296 ToValuesOpInterface, sparse_tensor::ToValuesOp> {
297 bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
302 bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
322 sparse_tensor::SparseTensorDialect *dialect) {
323 sparse_tensor::ConcatenateOp::attachInterface<ConcatenateOpInterface>(*ctx);
324 sparse_tensor::ConvertOp::attachInterface<ConvertOpInterface>(*ctx);
325 sparse_tensor::LoadOp::attachInterface<LoadOpInterface>(*ctx);
326 sparse_tensor::NewOp::attachInterface<NewOpInterface>(*ctx);
327 sparse_tensor::InsertOp::attachInterface<InsertOpInterface>(*ctx);
328 sparse_tensor::NumberOfEntriesOp::attachInterface<
329 NumberOfEntriesOpInterface>(*ctx);
330 sparse_tensor::AssembleOp::attachInterface<AssembleOpInterface>(*ctx);
331 sparse_tensor::DisassembleOp::attachInterface<DisassembleOpInterface>(*ctx);
332 sparse_tensor::ToCoordinatesBufferOp::attachInterface<
333 ToCoordinatesBufferOpInterface>(*ctx);
334 sparse_tensor::ToCoordinatesOp::attachInterface<ToCoordinatesOpInterface>(
336 sparse_tensor::ToPositionsOp::attachInterface<ToPositionsOpInterface>(*ctx);
337 sparse_tensor::ToValuesOp::attachInterface<ToValuesOpInterface>(*ctx);
static llvm::ManagedStatic< PassManagerOptions > options
The DialectRegistry maps a dialect namespace to a constructor for the matching dialect.
void addExtension(std::unique_ptr< DialectExtensionBase > extension)
Add the given extension to the registry.
MLIRContext is the top-level object for a collection of MLIR operations.
AnalysisState provides a variety of helper functions for dealing with tensor values.
BufferRelation
Specifies a fine-grain relationship between buffers to enable more analysis.
void registerBufferizableOpInterfaceExternalModels(DialectRegistry ®istry)
Include the generated interface declarations.
Options for BufferizableOpInterface-based bufferization.