275 lines
13 KiB
C++
275 lines
13 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Interface Declarations *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir {
|
|
|
|
/// Attribute interface describing how to map a region to a processing unit.
|
|
///
|
|
/// It is intended to be a generic mechanism for binding regions to execution
|
|
/// units of an actual or virtual device. Each device first expresses its own
|
|
/// mappings, and those mappings must implement this interface. These mappings
|
|
/// can be used by the device-specific code generators and the desired regions
|
|
/// can be connected to the given processing unit.
|
|
///
|
|
/// Currently, `scf.forall` uses this interface to express the mapping
|
|
/// of the loops it contains to the GPU's parallelism units such as threads and
|
|
/// thread blocks.
|
|
class DeviceMappingAttrInterface;
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// Attribute interface describing how to filter the processing units that a
|
|
/// region is mapped to.
|
|
///
|
|
/// For instance, consider the following example mask which specifies processing
|
|
/// units 2, 4 and 5 are active:
|
|
/// ```
|
|
/// 8 4 0
|
|
/// mask : 0 0 0 1 1 0 1 0 0
|
|
/// ```
|
|
/// The logical ID for an active processing unit is defined as its position
|
|
/// relative to the other active processing units. In this example, we have:
|
|
/// ```
|
|
/// Processing Unit LogicalID
|
|
/// 0 N/A
|
|
/// 1 N/A
|
|
/// 2 0
|
|
/// 3 N/A
|
|
/// 4 1
|
|
/// 5 2
|
|
/// 6 N/A
|
|
/// 7 N/A
|
|
/// ```
|
|
class DeviceMaskingAttrInterface;
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// Attribute interface describing how to map a region to a processing unit.
|
|
///
|
|
/// It is intended to be a generic mechanism for binding regions to execution
|
|
/// units of an actual or virtual device. Each device first expresses its own
|
|
/// mappings, and those mappings must implement this interface. These mappings
|
|
/// can be used by the device-specific code generators and the desired regions
|
|
/// can be connected to the given processing unit.
|
|
///
|
|
/// Currently, `scf.forall` uses this interface to express the mapping
|
|
/// of the loops it contains to the GPU's parallelism units such as threads and
|
|
/// thread blocks.
|
|
namespace detail {
|
|
struct DeviceMappingAttrInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
int64_t (*getMappingId)(const Concept *impl, ::mlir::Attribute );
|
|
bool (*isLinearMapping)(const Concept *impl, ::mlir::Attribute );
|
|
int64_t (*getRelativeIndex)(const Concept *impl, ::mlir::Attribute );
|
|
};
|
|
template<typename ConcreteAttr>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::DeviceMappingAttrInterface;
|
|
Model() : Concept{getMappingId, isLinearMapping, getRelativeIndex} {}
|
|
|
|
static inline int64_t getMappingId(const Concept *impl, ::mlir::Attribute tablegen_opaque_val);
|
|
static inline bool isLinearMapping(const Concept *impl, ::mlir::Attribute tablegen_opaque_val);
|
|
static inline int64_t getRelativeIndex(const Concept *impl, ::mlir::Attribute tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteAttr>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::DeviceMappingAttrInterface;
|
|
FallbackModel() : Concept{getMappingId, isLinearMapping, getRelativeIndex} {}
|
|
|
|
static inline int64_t getMappingId(const Concept *impl, ::mlir::Attribute tablegen_opaque_val);
|
|
static inline bool isLinearMapping(const Concept *impl, ::mlir::Attribute tablegen_opaque_val);
|
|
static inline int64_t getRelativeIndex(const Concept *impl, ::mlir::Attribute tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteModel, typename ConcreteAttr>
|
|
class ExternalModel : public FallbackModel<ConcreteModel> {
|
|
public:
|
|
using ConcreteEntity = ConcreteAttr;
|
|
};
|
|
};
|
|
template <typename ConcreteAttr>
|
|
struct DeviceMappingAttrInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class DeviceMappingAttrInterface : public ::mlir::AttributeInterface<DeviceMappingAttrInterface, detail::DeviceMappingAttrInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::AttributeInterface<DeviceMappingAttrInterface, detail::DeviceMappingAttrInterfaceInterfaceTraits>::AttributeInterface;
|
|
template <typename ConcreteAttr>
|
|
struct Trait : public detail::DeviceMappingAttrInterfaceTrait<ConcreteAttr> {};
|
|
|
|
/// Return mapping as an integer from the attribute.
|
|
int64_t getMappingId() const;
|
|
|
|
/// Return true if the attribute specifies a linear mapping
|
|
bool isLinearMapping() const;
|
|
|
|
/// Return the [0..n) relative index of the attribute depending on its group.
|
|
/// This can be used to index into a contiguous array.
|
|
int64_t getRelativeIndex() const;
|
|
};
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// Attribute interface describing how to filter the processing units that a
|
|
/// region is mapped to.
|
|
///
|
|
/// For instance, consider the following example mask which specifies processing
|
|
/// units 2, 4 and 5 are active:
|
|
/// ```
|
|
/// 8 4 0
|
|
/// mask : 0 0 0 1 1 0 1 0 0
|
|
/// ```
|
|
/// The logical ID for an active processing unit is defined as its position
|
|
/// relative to the other active processing units. In this example, we have:
|
|
/// ```
|
|
/// Processing Unit LogicalID
|
|
/// 0 N/A
|
|
/// 1 N/A
|
|
/// 2 0
|
|
/// 3 N/A
|
|
/// 4 1
|
|
/// 5 2
|
|
/// 6 N/A
|
|
/// 7 N/A
|
|
/// ```
|
|
namespace detail {
|
|
struct DeviceMaskingAttrInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
Value (*createLogicalLinearMappingId)(const Concept *impl, ::mlir::Attribute , OpBuilder&, Value);
|
|
Value (*createIsActiveIdPredicate)(const Concept *impl, ::mlir::Attribute , OpBuilder&, Value);
|
|
int64_t (*getMaxNumPhysicalIds)(const Concept *impl, ::mlir::Attribute );
|
|
};
|
|
template<typename ConcreteAttr>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::DeviceMaskingAttrInterface;
|
|
Model() : Concept{createLogicalLinearMappingId, createIsActiveIdPredicate, getMaxNumPhysicalIds} {}
|
|
|
|
static inline Value createLogicalLinearMappingId(const Concept *impl, ::mlir::Attribute tablegen_opaque_val, OpBuilder& builder, Value physicalLinearMappingId);
|
|
static inline Value createIsActiveIdPredicate(const Concept *impl, ::mlir::Attribute tablegen_opaque_val, OpBuilder& builder, Value physicalLinearMappingId);
|
|
static inline int64_t getMaxNumPhysicalIds(const Concept *impl, ::mlir::Attribute tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteAttr>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::DeviceMaskingAttrInterface;
|
|
FallbackModel() : Concept{createLogicalLinearMappingId, createIsActiveIdPredicate, getMaxNumPhysicalIds} {}
|
|
|
|
static inline Value createLogicalLinearMappingId(const Concept *impl, ::mlir::Attribute tablegen_opaque_val, OpBuilder& builder, Value physicalLinearMappingId);
|
|
static inline Value createIsActiveIdPredicate(const Concept *impl, ::mlir::Attribute tablegen_opaque_val, OpBuilder& builder, Value physicalLinearMappingId);
|
|
static inline int64_t getMaxNumPhysicalIds(const Concept *impl, ::mlir::Attribute tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteModel, typename ConcreteAttr>
|
|
class ExternalModel : public FallbackModel<ConcreteModel> {
|
|
public:
|
|
using ConcreteEntity = ConcreteAttr;
|
|
};
|
|
};
|
|
template <typename ConcreteAttr>
|
|
struct DeviceMaskingAttrInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class DeviceMaskingAttrInterface : public ::mlir::AttributeInterface<DeviceMaskingAttrInterface, detail::DeviceMaskingAttrInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::AttributeInterface<DeviceMaskingAttrInterface, detail::DeviceMaskingAttrInterfaceInterfaceTraits>::AttributeInterface;
|
|
template <typename ConcreteAttr>
|
|
struct Trait : public detail::DeviceMaskingAttrInterfaceTrait<ConcreteAttr> {};
|
|
|
|
/// Create the logical active id for a given physical id.
|
|
/// Expects a physicalLinearMappingId of I64Type.
|
|
Value createLogicalLinearMappingId(OpBuilder& builder, Value physicalLinearMappingId) const;
|
|
|
|
/// Return the dynamic condition determining whether a given physical id is
|
|
/// active under the mask.
|
|
/// Expects a physicalLinearMappingId of I64Type.
|
|
Value createIsActiveIdPredicate(OpBuilder& builder, Value physicalLinearMappingId) const;
|
|
|
|
/// Return the maximal number of pysical ids supported.
|
|
/// This is to account for temporary implementation limitations (e.g. i64)
|
|
/// and fail gracefully with actionnable error messages.
|
|
int64_t getMaxNumPhysicalIds() const;
|
|
};
|
|
|
|
} // namespace mlir
|
|
namespace mlir::detail {
|
|
|
|
template <typename ConcreteAttr>
|
|
struct DeviceMappingAttrInterfaceTrait : public ::mlir::AttributeInterface<DeviceMappingAttrInterface, detail::DeviceMappingAttrInterfaceInterfaceTraits>::Trait<ConcreteAttr> {
|
|
};
|
|
|
|
} // namespace mlir::detail
|
|
namespace mlir::detail {
|
|
|
|
template <typename ConcreteAttr>
|
|
struct DeviceMaskingAttrInterfaceTrait : public ::mlir::AttributeInterface<DeviceMaskingAttrInterface, detail::DeviceMaskingAttrInterfaceInterfaceTraits>::Trait<ConcreteAttr> {
|
|
};
|
|
|
|
} // namespace mlir::detail
|
|
namespace mlir {
|
|
|
|
template<typename ConcreteAttr>
|
|
int64_t detail::DeviceMappingAttrInterfaceInterfaceTraits::Model<ConcreteAttr>::getMappingId(const Concept *impl, ::mlir::Attribute tablegen_opaque_val) {
|
|
return (::llvm::cast<ConcreteAttr>(tablegen_opaque_val)).getMappingId();
|
|
}
|
|
template<typename ConcreteAttr>
|
|
bool detail::DeviceMappingAttrInterfaceInterfaceTraits::Model<ConcreteAttr>::isLinearMapping(const Concept *impl, ::mlir::Attribute tablegen_opaque_val) {
|
|
return (::llvm::cast<ConcreteAttr>(tablegen_opaque_val)).isLinearMapping();
|
|
}
|
|
template<typename ConcreteAttr>
|
|
int64_t detail::DeviceMappingAttrInterfaceInterfaceTraits::Model<ConcreteAttr>::getRelativeIndex(const Concept *impl, ::mlir::Attribute tablegen_opaque_val) {
|
|
return (::llvm::cast<ConcreteAttr>(tablegen_opaque_val)).getRelativeIndex();
|
|
}
|
|
template<typename ConcreteAttr>
|
|
int64_t detail::DeviceMappingAttrInterfaceInterfaceTraits::FallbackModel<ConcreteAttr>::getMappingId(const Concept *impl, ::mlir::Attribute tablegen_opaque_val) {
|
|
return static_cast<const ConcreteAttr *>(impl)->getMappingId(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteAttr>
|
|
bool detail::DeviceMappingAttrInterfaceInterfaceTraits::FallbackModel<ConcreteAttr>::isLinearMapping(const Concept *impl, ::mlir::Attribute tablegen_opaque_val) {
|
|
return static_cast<const ConcreteAttr *>(impl)->isLinearMapping(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteAttr>
|
|
int64_t detail::DeviceMappingAttrInterfaceInterfaceTraits::FallbackModel<ConcreteAttr>::getRelativeIndex(const Concept *impl, ::mlir::Attribute tablegen_opaque_val) {
|
|
return static_cast<const ConcreteAttr *>(impl)->getRelativeIndex(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
template<typename ConcreteAttr>
|
|
Value detail::DeviceMaskingAttrInterfaceInterfaceTraits::Model<ConcreteAttr>::createLogicalLinearMappingId(const Concept *impl, ::mlir::Attribute tablegen_opaque_val, OpBuilder& builder, Value physicalLinearMappingId) {
|
|
return (::llvm::cast<ConcreteAttr>(tablegen_opaque_val)).createLogicalLinearMappingId(builder, physicalLinearMappingId);
|
|
}
|
|
template<typename ConcreteAttr>
|
|
Value detail::DeviceMaskingAttrInterfaceInterfaceTraits::Model<ConcreteAttr>::createIsActiveIdPredicate(const Concept *impl, ::mlir::Attribute tablegen_opaque_val, OpBuilder& builder, Value physicalLinearMappingId) {
|
|
return (::llvm::cast<ConcreteAttr>(tablegen_opaque_val)).createIsActiveIdPredicate(builder, physicalLinearMappingId);
|
|
}
|
|
template<typename ConcreteAttr>
|
|
int64_t detail::DeviceMaskingAttrInterfaceInterfaceTraits::Model<ConcreteAttr>::getMaxNumPhysicalIds(const Concept *impl, ::mlir::Attribute tablegen_opaque_val) {
|
|
return (::llvm::cast<ConcreteAttr>(tablegen_opaque_val)).getMaxNumPhysicalIds();
|
|
}
|
|
template<typename ConcreteAttr>
|
|
Value detail::DeviceMaskingAttrInterfaceInterfaceTraits::FallbackModel<ConcreteAttr>::createLogicalLinearMappingId(const Concept *impl, ::mlir::Attribute tablegen_opaque_val, OpBuilder& builder, Value physicalLinearMappingId) {
|
|
return static_cast<const ConcreteAttr *>(impl)->createLogicalLinearMappingId(tablegen_opaque_val, builder, physicalLinearMappingId);
|
|
}
|
|
template<typename ConcreteAttr>
|
|
Value detail::DeviceMaskingAttrInterfaceInterfaceTraits::FallbackModel<ConcreteAttr>::createIsActiveIdPredicate(const Concept *impl, ::mlir::Attribute tablegen_opaque_val, OpBuilder& builder, Value physicalLinearMappingId) {
|
|
return static_cast<const ConcreteAttr *>(impl)->createIsActiveIdPredicate(tablegen_opaque_val, builder, physicalLinearMappingId);
|
|
}
|
|
template<typename ConcreteAttr>
|
|
int64_t detail::DeviceMaskingAttrInterfaceInterfaceTraits::FallbackModel<ConcreteAttr>::getMaxNumPhysicalIds(const Concept *impl, ::mlir::Attribute tablegen_opaque_val) {
|
|
return static_cast<const ConcreteAttr *>(impl)->getMaxNumPhysicalIds(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir
|