Commit a248fa90 authored by Frank Laub's avatar Frank Laub
Browse files

[MLIR][Affine] NFC: Move AffineValueMap and MutableAffineMap 

Summary:
The `AffineValueMap` is moved into `Dialect/AffineOps` to prevent a cyclic
dependency between `Analysis` and `Dialect/AffineOps`.

Reviewers: bondhugula, herhut, nicolasvasilache, rriddle, mehdi_amini

Reviewed By: rriddle, mehdi_amini

Subscribers: mgorny, mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, aartbik, liufengdb, Joonsoo, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D74277
parent 76f888d0

mlir/include/mlir/Analysis/AffineStructures.h

+3 −115
Original line number Diff line number Diff line
@@ -19,56 +19,16 @@ 


namespace mlir {



class AffineApplyOp;

class AffineBound;

class AffineCondition;

class AffineMap;

class AffineForOp;

class AffineMap;

class AffineValueMap;

class IntegerSet;

class MLIRContext;

class Value;

class HyperRectangularSet;

class MemRefType;



/// A mutable affine map. Its affine expressions are however unique.

struct MutableAffineMap {

public:

  MutableAffineMap() {}

  MutableAffineMap(AffineMap map);



  ArrayRef<AffineExpr> getResults() const { return results; }

  AffineExpr getResult(unsigned idx) const { return results[idx]; }

  void setResult(unsigned idx, AffineExpr result) { results[idx] = result; }

  unsigned getNumResults() const { return results.size(); }

  unsigned getNumDims() const { return numDims; }

  void setNumDims(unsigned d) { numDims = d; }

  unsigned getNumSymbols() const { return numSymbols; }

  void setNumSymbols(unsigned d) { numSymbols = d; }

  MLIRContext *getContext() const { return context; }



  /// Returns true if the idx'th result expression is a multiple of factor.

  bool isMultipleOf(unsigned idx, int64_t factor) const;



  /// Resets this MutableAffineMap with 'map'.

  void reset(AffineMap map);



  /// Simplify the (result) expressions in this map using analysis (used by

  //-simplify-affine-expr pass).

  void simplify();

  /// Get the AffineMap corresponding to this MutableAffineMap. Note that an

  /// AffineMap will be uniqued and stored in context, while a mutable one

  /// isn't.

  AffineMap getAffineMap() const;



private:

  // Same meaning as AffineMap's fields.

  SmallVector<AffineExpr, 8> results;

  unsigned numDims;

  unsigned numSymbols;

  /// A pointer to the IR's context to store all newly created

  /// AffineExprStorage's.

  MLIRContext *context;

};

struct MutableAffineMap;



/// A mutable integer set. Its affine expressions are however unique.

struct MutableIntegerSet {
@@ -96,78 +56,6 @@ private: 
  SmallVector<bool, 8> eqFlags;

};



/// An AffineValueMap is an affine map plus its ML value operands and

/// results for analysis purposes. The structure is still a tree form that is

/// same as that of an affine map or an AffineApplyOp. However, its operands,

/// results, and its map can themselves change  as a result of

/// substitutions, simplifications, and other analysis.

// An affine value map can readily be constructed from an AffineApplyOp, or an

// AffineBound of a AffineForOp. It can be further transformed, substituted

// into, or simplified. Unlike AffineMap's, AffineValueMap's are created and

// destroyed during analysis. Only the AffineMap expressions that are pointed by

// them are unique'd. An affine value map, and the operations on it, maintain

// the invariant that operands are always positionally aligned with the

// AffineDimExpr and AffineSymbolExpr in the underlying AffineMap.

// TODO(bondhugula): Some of these classes could go into separate files.

class AffineValueMap {

public:

  // Creates an empty AffineValueMap (users should call 'reset' to reset map

  // and operands).

  AffineValueMap() {}

  AffineValueMap(AffineMap map, ArrayRef<Value> operands,

                 ArrayRef<Value> results = llvm::None);



  explicit AffineValueMap(AffineApplyOp applyOp);

  explicit AffineValueMap(AffineBound bound);



  ~AffineValueMap();



  // Resets this AffineValueMap with 'map', 'operands', and 'results'.

  void reset(AffineMap map, ArrayRef<Value> operands,

             ArrayRef<Value> results = llvm::None);



  /// Return the value map that is the difference of value maps 'a' and 'b',

  /// represented as an affine map and its operands. The output map + operands

  /// are canonicalized and simplified.

  static void difference(const AffineValueMap &a, const AffineValueMap &b,

                         AffineValueMap *res);



  /// Return true if the idx^th result can be proved to be a multiple of

  /// 'factor', false otherwise.

  inline bool isMultipleOf(unsigned idx, int64_t factor) const;



  /// Return true if the idx^th result depends on 'value', false otherwise.

  bool isFunctionOf(unsigned idx, Value value) const;



  /// Return true if the result at 'idx' is a constant, false

  /// otherwise.

  bool isConstant(unsigned idx) const;



  /// Return true if this is an identity map.

  bool isIdentity() const;



  void setResult(unsigned i, AffineExpr e) { map.setResult(i, e); }

  AffineExpr getResult(unsigned i) { return map.getResult(i); }

  inline unsigned getNumOperands() const { return operands.size(); }

  inline unsigned getNumDims() const { return map.getNumDims(); }

  inline unsigned getNumSymbols() const { return map.getNumSymbols(); }

  inline unsigned getNumResults() const { return map.getNumResults(); }



  Value getOperand(unsigned i) const;

  ArrayRef<Value> getOperands() const;

  AffineMap getAffineMap() const;



private:

  // A mutable affine map.

  MutableAffineMap map;



  // TODO: make these trailing objects?

  /// The SSA operands binding to the dim's and symbols of 'map'.

  SmallVector<Value, 4> operands;

  /// The SSA results binding to the results of 'map'.

  SmallVector<Value, 4> results;

};



/// An IntegerValueSet is an integer set plus its operands.

// Both, the integer set being pointed to and the operands can change during

// analysis, simplification, and transformation.

mlir/include/mlir/Dialect/AffineOps/AffineOps.h

+4 −3
Original line number Diff line number Diff line
@@ -73,6 +73,9 @@ public: 
    return getAttrOfType<AffineMapAttr>("map").getValue();

  }



  /// Returns the affine value map computed from this operation.

  AffineValueMap getAffineValueMap();



  /// Returns true if the result of this operation can be used as dimension id.

  bool isValidDim();
@@ -528,6 +531,7 @@ bool isValidSymbol(Value value); 
/// 4. propagate constant operands and drop them

void canonicalizeMapAndOperands(AffineMap *map,

                                SmallVectorImpl<Value> *operands);



/// Canonicalizes an integer set the same way canonicalizeMapAndOperands does

/// for affine maps.

void canonicalizeSetAndOperands(IntegerSet *set,
@@ -573,9 +577,6 @@ public: 
  AffineForOp getAffineForOp() { return op; }

  AffineMap getMap() { return map; }



  /// Returns an AffineValueMap representing this bound.

  AffineValueMap getAsAffineValueMap();



  unsigned getNumOperands() { return opEnd - opStart; }

  Value getOperand(unsigned idx) { return op.getOperand(opStart + idx); }

mlir/include/mlir/Dialect/AffineOps/AffineValueMap.h

0 → 100644
+90 −0
Original line number Diff line number Diff line 
//===- AffineValueMap.h - MLIR Affine Value Map Class -----------*- C++ -*-===//

//

// 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

//

//===----------------------------------------------------------------------===//

//

// An AffineValueMap is an affine map plus its ML value operands and results for

// analysis purposes.

//===----------------------------------------------------------------------===//



#ifndef MLIR_DIALECT_AFFINEOPS_AFFINEVALUEMAP_H

#define MLIR_DIALECT_AFFINEOPS_AFFINEVALUEMAP_H



#include "mlir/IR/AffineMap.h"

#include "mlir/IR/OperationSupport.h"

#include "mlir/IR/Value.h"



namespace mlir {



/// An AffineValueMap is an affine map plus its ML value operands and

/// results for analysis purposes. The structure is still a tree form that is

/// same as that of an affine map or an AffineApplyOp. However, its operands,

/// results, and its map can themselves change  as a result of

/// substitutions, simplifications, and other analysis.

// An affine value map can readily be constructed from an AffineApplyOp, or an

// AffineBound of a AffineForOp. It can be further transformed, substituted

// into, or simplified. Unlike AffineMap's, AffineValueMap's are created and

// destroyed during analysis. Only the AffineMap expressions that are pointed by

// them are unique'd. An affine value map, and the operations on it, maintain

// the invariant that operands are always positionally aligned with the

// AffineDimExpr and AffineSymbolExpr in the underlying AffineMap.

class AffineValueMap {

public:

  // Creates an empty AffineValueMap (users should call 'reset' to reset map

  // and operands).

  AffineValueMap() {}

  AffineValueMap(AffineMap map, ValueRange operands, ValueRange results = {});



  ~AffineValueMap();



  // Resets this AffineValueMap with 'map', 'operands', and 'results'.

  void reset(AffineMap map, ValueRange operands, ValueRange results = {});



  /// Return the value map that is the difference of value maps 'a' and 'b',

  /// represented as an affine map and its operands. The output map + operands

  /// are canonicalized and simplified.

  static void difference(const AffineValueMap &a, const AffineValueMap &b,

                         AffineValueMap *res);



  /// Return true if the idx^th result can be proved to be a multiple of

  /// 'factor', false otherwise.

  inline bool isMultipleOf(unsigned idx, int64_t factor) const;



  /// Return true if the idx^th result depends on 'value', false otherwise.

  bool isFunctionOf(unsigned idx, Value value) const;



  /// Return true if the result at 'idx' is a constant, false

  /// otherwise.

  bool isConstant(unsigned idx) const;



  /// Return true if this is an identity map.

  bool isIdentity() const;



  void setResult(unsigned i, AffineExpr e) { map.setResult(i, e); }

  AffineExpr getResult(unsigned i) { return map.getResult(i); }

  inline unsigned getNumOperands() const { return operands.size(); }

  inline unsigned getNumDims() const { return map.getNumDims(); }

  inline unsigned getNumSymbols() const { return map.getNumSymbols(); }

  inline unsigned getNumResults() const { return map.getNumResults(); }



  Value getOperand(unsigned i) const;

  ArrayRef<Value> getOperands() const;

  AffineMap getAffineMap() const;



private:

  // A mutable affine map.

  MutableAffineMap map;



  // TODO: make these trailing objects?

  /// The SSA operands binding to the dim's and symbols of 'map'.

  SmallVector<Value, 4> operands;

  /// The SSA results binding to the results of 'map'.

  SmallVector<Value, 4> results;

};



} // namespace mlir



#endif // MLIR_DIALECT_AFFINEOPS_AFFINEVALUEMAP_H

mlir/include/mlir/IR/AffineMap.h

+43 −2
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
#ifndef MLIR_IR_AFFINE_MAP_H

#define MLIR_IR_AFFINE_MAP_H



#include "mlir/IR/AffineExpr.h"

#include "mlir/Support/LLVM.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMapInfo.h"
@@ -24,7 +25,6 @@ namespace detail { 
struct AffineMapStorage;

} // end namespace detail



class AffineExpr;

class Attribute;

struct LogicalResult;

class MLIRContext;
@@ -155,6 +155,46 @@ inline ::llvm::hash_code hash_value(AffineMap arg) { 
  return ::llvm::hash_value(arg.map);

}



/// A mutable affine map. Its affine expressions are however unique.

struct MutableAffineMap {

public:

  MutableAffineMap() {}

  MutableAffineMap(AffineMap map);



  ArrayRef<AffineExpr> getResults() const { return results; }

  AffineExpr getResult(unsigned idx) const { return results[idx]; }

  void setResult(unsigned idx, AffineExpr result) { results[idx] = result; }

  unsigned getNumResults() const { return results.size(); }

  unsigned getNumDims() const { return numDims; }

  void setNumDims(unsigned d) { numDims = d; }

  unsigned getNumSymbols() const { return numSymbols; }

  void setNumSymbols(unsigned d) { numSymbols = d; }

  MLIRContext *getContext() const { return context; }



  /// Returns true if the idx'th result expression is a multiple of factor.

  bool isMultipleOf(unsigned idx, int64_t factor) const;



  /// Resets this MutableAffineMap with 'map'.

  void reset(AffineMap map);



  /// Simplify the (result) expressions in this map using analysis (used by

  //-simplify-affine-expr pass).

  void simplify();

  /// Get the AffineMap corresponding to this MutableAffineMap. Note that an

  /// AffineMap will be uniqued and stored in context, while a mutable one

  /// isn't.

  AffineMap getAffineMap() const;



private:

  // Same meaning as AffineMap's fields.

  SmallVector<AffineExpr, 8> results;

  unsigned numDims;

  unsigned numSymbols;

  /// A pointer to the IR's context to store all newly created

  /// AffineExprStorage's.

  MLIRContext *context;

};



/// Simplify an affine map by simplifying its underlying AffineExpr results.

AffineMap simplifyAffineMap(AffineMap map);
@@ -227,7 +267,8 @@ inline raw_ostream &operator<<(raw_ostream &os, AffineMap map) { 
namespace llvm {



// AffineExpr hash just like pointers

template <> struct DenseMapInfo<mlir::AffineMap> {

template <>

struct DenseMapInfo<mlir::AffineMap> {

  static mlir::AffineMap getEmptyKey() {

    auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();

    return mlir::AffineMap(static_cast<mlir::AffineMap::ImplType *>(pointer));

mlir/lib/Analysis/AffineAnalysis.cpp

+1 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
#include "mlir/Analysis/AffineStructures.h"

#include "mlir/Analysis/Utils.h"

#include "mlir/Dialect/AffineOps/AffineOps.h"

#include "mlir/Dialect/AffineOps/AffineValueMap.h"

#include "mlir/Dialect/StandardOps/Ops.h"

#include "mlir/IR/AffineExprVisitor.h"

#include "mlir/IR/Builders.h"