// Computes the iteration domain for 'opInst' and populates 'indexSet', which
// encapsulates the constraints involving loops surrounding 'opInst' and
// potentially involving any Function symbols. The dimensional identifiers in
-// 'indexSet' correspond to the loops surounding 'op' from outermost to
+// 'indexSet' correspond to the loops surrounding 'op' from outermost to
// innermost.
// TODO(andydavis) Add support to handle IfInsts surrounding 'op'.
static LogicalResult getInstIndexSet(Operation *op,
// Position lookups return the absolute position in the new space which
// has the following format:
//
-// [src-dim-identifiers] [dst-dim-identifiers] [symbol-identifers]
+// [src-dim-identifiers] [dst-dim-identifiers] [symbol-identifiers]
//
// Note: access function non-IV dimension identifiers (that have 'dimension'
// positions in the access function position space) are assigned as symbols
-// in the output position space. Convienience access functions which lookup
+// in the output position space. Convenience access functions which lookup
// an Value in multiple maps are provided (i.e. getSrcDimOrSymPos) to handle
// the common case of resolving positions for all access function operands.
//
dependenceDomain->addDimId(j);
}
- // Add equality contraints for each common loop, setting newly introduced
+ // Add equality constraints for each common loop, setting newly introduced
// variable at column 'j' to the 'dst' IV minus the 'src IV.
SmallVector<int64_t, 4> eq;
eq.resize(dependenceDomain->getNumCols());
// composed with AffineApplyOps reachable from operands of that access,
// until operands of the AffineValueMap are loop IVs or symbols.
// *) Build iteration domain constraints for each access. Iteration domain
-// constraints are pairs of inequality contraints representing the
+// constraints are pairs of inequality constraints representing the
// upper/lower loop bounds for each AffineForOp in the loop nest associated
// with each access.
// *) Build dimension and symbol position maps for each access, which map
//
// [src-dim-identifiers, dst-dim-identifiers, symbols, constant]
//
-// For example, given the following MLIR code with with "source" and
-// "destination" accesses to the same memref labled, and symbols %M, %N, %K:
+// For example, given the following MLIR code with "source" and "destination"
+// accesses to the same memref label, and symbols %M, %N, %K:
//
// affine.for %i0 = 0 to 100 {
// affine.for %i1 = 0 to 50 {
return DependenceResult::NoDependence;
}
// Build dim and symbol position maps for each access from access operand
- // Value to position in merged contstraint system.
+ // Value to position in merged constraint system.
ValuePositionMap valuePosMap;
buildDimAndSymbolPositionMaps(srcDomain, dstDomain, srcAccessMap,
dstAccessMap, &valuePosMap,
}
// Normalizes the coefficient values across all columns in 'rowIDx' by their
-// GCD in equality or inequality contraints as specified by 'isEq'.
+// GCD in equality or inequality constraints as specified by 'isEq'.
template <bool isEq>
static void normalizeConstraintByGCD(FlatAffineConstraints *constraints,
unsigned rowIdx) {
getBestIdToEliminate(tmpCst, 0, tmpCst.getNumIds()));
// Check for a constraint explosion. This rarely happens in practice, but
// this check exists as a safeguard against improperly constructed
- // constraint systems or artifically created arbitrarily complex systems
+ // constraint systems or artificially created arbitrarily complex systems
// that aren't the intended use case for FlatAffineConstraints. This is
// needed since FM has a worst case exponential complexity in theory.
if (tmpCst.getNumConstraints() >= kExplosionFactor * getNumIds()) {
}
}
-// Eliminates all identifer variables in column range [posStart, posLimit).
+// Eliminates all identifier variables in column range [posStart, posLimit).
// Returns the number of variables eliminated.
unsigned FlatAffineConstraints::gaussianEliminateIds(unsigned posStart,
unsigned posLimit) {
// Work on a copy so that we don't update this constraint system.
if (!tmpClone) {
tmpClone.emplace(FlatAffineConstraints(*this));
- // Removing redudnant inequalities is necessary so that we don't get
+ // Removing redundant inequalities is necessary so that we don't get
// redundant loop bounds.
tmpClone->removeRedundantInequalities();
}
if (eq)
lower = true;
- // Fully commpose map and operands; canonicalize and simplify so that we
+ // Fully compose map and operands; canonicalize and simplify so that we
// transitively get to terminal symbols or loop IVs.
auto map = boundMap;
SmallVector<Value *, 4> operands(boundOperands.begin(), boundOperands.end());
numSymbols = newSymbolCount;
}
-/// Sets the specified identifer to a constant value.
+/// Sets the specified identifier to a constant value.
void FlatAffineConstraints::setIdToConstant(unsigned pos, int64_t val) {
unsigned offset = equalities.size();
equalities.resize(equalities.size() + numReservedCols);
equalities[offset + getNumCols() - 1] = -val;
}
-/// Sets the specified identifer to a constant value; asserts if the id is not
+/// Sets the specified identifier to a constant value; asserts if the id is not
/// found.
void FlatAffineConstraints::setIdToConstant(Value &id, int64_t val) {
unsigned pos;
// limitations under the License.
// =============================================================================
//
-// This file implements a pass to check memref accessses for out of bound
+// This file implements a pass to check memref accesses for out of bound
// accesses.
//
//===----------------------------------------------------------------------===//
/// there is no match;
/// 2. calls the customizable filter function to refine the single operation
/// match with extra semantic constraints;
-/// 3. if all is good, recursivey matches the nested patterns;
+/// 3. if all is good, recursively matches the nested patterns;
/// 4. if all nested match then the single operation matches too and is
/// appended to the list of matches;
/// 5. TODO(ntv) Optionally applies actions (lambda), in which case we will
return result;
}
-// For each access in 'loadsAndStores', runs a depence check between this
+// For each access in 'loadsAndStores', runs a dependence check between this
// "source" access and all subsequent "destination" accesses in
// 'loadsAndStores'. Emits the result of the dependence check as a note with
// the source access.
void mlir::getLoopIVs(Operation &op, SmallVectorImpl<AffineForOp> *loops) {
auto *currOp = op.getParentOp();
AffineForOp currAffineForOp;
- // Traverse up the hierarchy collecing all 'affine.for' operation while
+ // Traverse up the hierarchy collecting all 'affine.for' operation while
// skipping over 'affine.if' operations.
while (currOp && ((currAffineForOp = dyn_cast<AffineForOp>(currOp)) ||
isa<AffineIfOp>(currOp))) {
cst.reset(numDims, numSymbols, 0, operands);
// Add equality constraints.
- // Add inequalties for loop lower/upper bounds.
+ // Add inequalities for loop lower/upper bounds.
for (unsigned i = 0; i < numDims + numSymbols; ++i) {
auto *operand = operands[i];
if (auto loop = getForInductionVarOwner(operand)) {
bool mlir::matcher::operatesOnSuperVectorsOf(Operation &op,
VectorType subVectorType) {
- // First, extract the vector type and ditinguish between:
+ // First, extract the vector type and distinguish between:
// a. ops that *must* lower a super-vector (i.e. vector.transfer_read,
// vector.transfer_write); and
// b. ops that *may* lower a super-vector (all other ops).
std::string translateModuleToPtx(llvm::Module &module,
llvm::TargetMachine &target_machine);
- /// Converts llvmModule to cubin using the user-provded generator. Location is
- /// used for error reporting and name is forwarded to the CUBIN generator to
- /// use in its logging mechanisms.
+ /// Converts llvmModule to cubin using the user-provided generator. Location
+ /// is used for error reporting and name is forwarded to the CUBIN generator
+ /// to use in its logging mechanisms.
OwnedCubin convertModuleToCubin(llvm::Module &llvmModule, Location loc,
StringRef name);
/// Convert load -> spv.LoadOp. The operands of the replaced operation are of
/// IndexType while that of the replacement operation are of type i32. This is
-/// not suppored in tablegen based pattern specification.
+/// not supported in tablegen based pattern specification.
// TODO(ravishankarm) : These could potentially be templated on the operation
// being converted, since the same logic should work for linalg.load.
class LoadOpConversion final : public ConversionPattern {
/// Convert store -> spv.StoreOp. The operands of the replaced operation are of
/// IndexType while that of the replacement operation are of type i32. This is
-/// not suppored in tablegen based pattern specification.
+/// not supported in tablegen based pattern specification.
// TODO(ravishankarm) : These could potentially be templated on the operation
// being converted, since the same logic should work for linalg.store.
class StoreOpConversion final : public ConversionPattern {
info.rhsType.getScale() /
info.resultType.getScale();
if (outputMultiplierReal > 1.0) {
- info.op->emitWarning("unimplemented: cannot multiply with multipler > 1.0");
+ info.op->emitWarning(
+ "unimplemented: cannot multiply with multiplier > 1.0");
return failure();
}
-//===- KernelOutlining.cpp - Implementation of GPU kernel outling ---------===//
+//===- KernelOutlining.cpp - Implementation of GPU kernel outlining -------===//
//
// Copyright 2019 The MLIR Authors.
//
// Infer the element type from the structure type: iteratively step inside the
// type by taking the element type, indexed by the position attribute for
- // stuctures. Check the position index before accessing, it is supposed to be
- // in bounds.
+ // structures. Check the position index before accessing, it is supposed to
+ // be in bounds.
for (Attribute subAttr : positionArrayAttr) {
auto positionElementAttr = subAttr.dyn_cast<IntegerAttr>();
if (!positionElementAttr)
LLVM::LLVMDialect *llvmDialect) {
assert(builder.getInsertionBlock() &&
builder.getInsertionBlock()->getParentOp() &&
- "expected builder to point to a block constained in an op");
+ "expected builder to point to a block constrained in an op");
auto module =
builder.getInsertionBlock()->getParentOp()->getParentOfType<ModuleOp>();
assert(module && "builder points to an op outside of a module");
TransposeOpOperandAdaptor adaptor(operands);
Value *baseDesc = adaptor.view();
- auto tranposeOp = cast<TransposeOp>(op);
+ auto transposeOp = cast<TransposeOp>(op);
// No permutation, early exit.
- if (tranposeOp.permutation().isIdentity())
+ if (transposeOp.permutation().isIdentity())
return rewriter.replaceOp(op, baseDesc), matchSuccess();
- BaseViewConversionHelper helper(op->getLoc(), tranposeOp.getViewType(),
+ BaseViewConversionHelper helper(op->getLoc(), transposeOp.getViewType(),
rewriter, lowering);
LLVMType elementTy = helper.elementTy, int64Ty = helper.int64Ty;
Value *desc = helper.desc;
desc = insertvalue(desc, extractvalue(int64Ty, baseDesc, offPos), offPos);
// Iterate over the dimensions and apply size/stride permutation.
- for (auto en : llvm::enumerate(tranposeOp.permutation().getResults())) {
+ for (auto en : llvm::enumerate(transposeOp.permutation().getResults())) {
int sourcePos = en.index();
int targetPos = en.value().cast<AffineDimExpr>().getPosition();
Value *size = extractvalue(int64Ty, baseDesc,
visit(expr.getRHS());
if (expr.getKind() == mlir::AffineExprKind::Mul)
assert(expr.getRHS().cast<AffineConstantExpr>().getValue() > 0 &&
- "nonpositive multipliying coefficient");
+ "nonpositive multiplying coefficient");
}
bool isTiled;
ArrayRef<Value *> tileSizes;
};
// We pass scales and zeroPoints in directly rather than relying on KeyTy
- // because we have to create new reallocated versions in `constrcut` below.
+ // because we have to create new reallocated versions in `construct` below.
UniformQuantizedPerAxisTypeStorage(const KeyTy &key, ArrayRef<double> scales,
ArrayRef<int64_t> zeroPoints)
: QuantizedTypeStorage(key.flags, key.storageType, key.expressedType,
// If 0.0 < rmin < rmax or rmin < rmax < 0.0, the range will be shifted
// to include 0.0, but the range width size (rmax-rmin) isn't changed. The zero
// point is derived from the shifted range, and the scale isn't changed. As
-// a consequence some values, which are supposeed in the original [rmin, rmax]
+// a consequence some values, which are supposed in the original [rmin, rmax]
// range will be outside the shifted range and be clamped during quantization.
// TODO(fengliuai): we should nudge the scale as well, but that requires the
// fake quant op used in the training to use the nudged scale as well.
// Construct an expression lhs + constant while maintaining the canonical form
// of the SDBM expressions, in particular sink the constant expression to the
-// nearest sum expression in the left subtree of the expresison tree.
+// nearest sum expression in the left subtree of the expression tree.
static SDBMExpr addConstant(SDBMVaryingExpr lhs, int64_t constant) {
if (auto lhsDiff = lhs.dyn_cast<SDBMDiffExpr>())
return addConstantAndSink<SDBMExpr>(
assert(!lhs.isa<SDBMConstantExpr>() && "non-canonical affine expression");
// If RHS is a constant, we can always extend the SDBM expression to
- // include it by sinking the constant into the nearest sum expresion.
+ // include it by sinking the constant into the nearest sum expression.
if (auto rhsConstant = rhs.dyn_cast<SDBMConstantExpr>()) {
int64_t constant = rhsConstant.getValue();
auto varying = lhs.dyn_cast<SDBMVaryingExpr>();
} else {
return parser.emitError(
attrLocation,
- "expexted an 32-bit integer for index, but found '")
+ "expected an 32-bit integer for index, but found '")
<< indexAttr << "'";
}
if (!indicesArrayAttr.size()) {
return compExOp.emitOpError(
- "expexted at least one index for spv.CompositeExtractOp");
+ "expected at least one index for spv.CompositeExtractOp");
}
int32_t index;
if (type.getKind() >= Type::FIRST_SPIRV_TYPE &&
type.getKind() <= spirv::TypeKind::LAST_SPIRV_TYPE) {
- // TODO(antiagainst): support contant struct
+ // TODO(antiagainst): support constant struct
return type.isa<spirv::ArrayType>();
}
// limitations under the License.
// =============================================================================
//
-// This file defines the SPIR-V binary to MLIR SPIR-V module deseralization.
+// This file defines the SPIR-V binary to MLIR SPIR-V module deserialization.
//
//===----------------------------------------------------------------------===//
/// in the deserializer.
LogicalResult processCapability(ArrayRef<uint32_t> operands);
- /// Attaches all collected capabilites to `module` as an attribute.
+ /// Attaches all collected capabilities to `module` as an attribute.
void attachCapabilities();
/// Processes the SPIR-V OpExtension with `operands` and updates bookkeeping
/// Gets the constant's attribute and type associated with the given <id>.
Optional<std::pair<Attribute, Type>> getConstant(uint32_t id);
- /// Gets the constants's integer attribute with the given <id>. Returns a null
+ /// Gets the constant's integer attribute with the given <id>. Returns a null
/// IntegerAttr if the given is not registered or does not correspond to an
/// integer constant.
IntegerAttr getConstantInt(uint32_t id);
/// This method is the main entrance for handling SPIR-V instruction; it
/// checks the instruction opcode and dispatches to the corresponding handler.
/// Processing of Some instructions (like OpEntryPoint and OpExecutionMode)
- /// might need to be defered, since they contain forward references to <id>s
+ /// might need to be deferred, since they contain forward references to <id>s
/// in the deserialized binary, but module in SPIR-V dialect expects these to
/// be ssa-uses.
LogicalResult processInstruction(spirv::Opcode opcode,
// Result <id> to extended instruction set name.
DenseMap<uint32_t, StringRef> extendedInstSets;
- // List of instructions that are processed in a defered fashion (after an
+ // List of instructions that are processed in a deferred fashion (after an
// initial processing of the entire binary). Some operations like
// OpEntryPoint, and OpExecutionMode use forward references to function
// <id>s. In SPIR-V dialect the corresponding operations (spv.EntryPoint and
// are deserialized and stored for processing once the entire binary is
// processed.
SmallVector<std::pair<spirv::Opcode, ArrayRef<uint32_t>>, 4>
- deferedInstructions;
+ deferredInstructions;
};
} // namespace
auto binarySize = binary.size();
while (curOffset < binarySize) {
// Slice the next instruction out and populate `opcode` and `operands`.
- // Interally this also updates `curOffset`.
+ // Internally this also updates `curOffset`.
if (failed(sliceInstruction(opcode, operands)))
return failure();
assert(curOffset == binarySize &&
"deserializer should never index beyond the binary end");
- for (auto &defered : deferedInstructions) {
- if (failed(processInstruction(defered.first, defered.second, false))) {
+ for (auto &deferred : deferredInstructions) {
+ if (failed(processInstruction(deferred.first, deferred.second, false))) {
return failure();
}
}
if (words.size() < 2) {
return emitError(unknownLoc,
"OpExtInstImport must have a result <id> and a literal "
- "string for the extensed instruction set name");
+ "string for the extended instruction set name");
}
unsigned wordIndex = 1;
floatTy = opBuilder.getF64Type();
break;
default:
- return emitError(unknownLoc, "unsupported OpTypeFloat bitwdith: ")
+ return emitError(unknownLoc, "unsupported OpTypeFloat bitwidth: ")
<< operands[1];
}
typeMap[operands[0]] = floatTy;
case spirv::Opcode::OpEntryPoint:
case spirv::Opcode::OpExecutionMode:
if (deferInstructions) {
- deferedInstructions.emplace_back(opcode, operands);
+ deferredInstructions.emplace_back(opcode, operands);
return success();
}
break;
// limitations under the License.
// =============================================================================
//
-// This file defines the MLIR SPIR-V module to SPIR-V binary seralization.
+// This file defines the MLIR SPIR-V module to SPIR-V binary serialization.
//
//===----------------------------------------------------------------------===//
template <typename DType>
LogicalResult processTypeDecoration(Location loc, DType type,
uint32_t resultId) {
- return emitError(loc, "unhandled decoraion for type:") << type;
+ return emitError(loc, "unhandled decoration for type:") << type;
}
/// Process member decoration
processExtension();
processMemoryModel();
- // Iterate over the module body to serialze it. Assumptions are that there is
+ // Iterate over the module body to serialize it. Assumptions are that there is
// only one basic block in the moduleOp
for (auto &op : module.getBlock()) {
if (failed(processOperation(&op))) {
uint32_t Serializer::prepareConstantBool(Location loc, BoolAttr boolAttr,
bool isSpec) {
if (!isSpec) {
- // We can de-duplicate nomral contants, but not specialization constants.
+ // We can de-duplicate normal constants, but not specialization constants.
if (auto id = getConstantID(boolAttr)) {
return id;
}
uint32_t Serializer::prepareConstantInt(Location loc, IntegerAttr intAttr,
bool isSpec) {
if (!isSpec) {
- // We can de-duplicate nomral contants, but not specialization constants.
+ // We can de-duplicate normal constants, but not specialization constants.
if (auto id = getConstantID(intAttr)) {
return id;
}
uint32_t Serializer::prepareConstantFp(Location loc, FloatAttr floatAttr,
bool isSpec) {
if (!isSpec) {
- // We can de-duplicate nomral contants, but not specialization constants.
+ // We can de-duplicate normal constants, but not specialization constants.
if (auto id = getConstantID(floatAttr)) {
return id;
}
LogicalResult
Serializer::processOp<spirv::EntryPointOp>(spirv::EntryPointOp op) {
SmallVector<uint32_t, 4> operands;
- // Add the ExectionModel.
+ // Add the ExecutionModel.
operands.push_back(static_cast<uint32_t>(op.execution_model()));
// Add the function <id>.
auto funcID = getFunctionID(op.fn());
if (targetMachine) {
// Add pass to initialize TTI for this specific target. Otherwise, TTI will
- // be initialized to NoTTIImpl by defaul.
+ // be initialized to NoTTIImpl by default.
modulePM.add(createTargetTransformInfoWrapperPass(
targetMachine->getTargetIRAnalysis()));
funcPM.add(createTargetTransformInfoWrapperPass(
}
//===----------------------------------------------------------------------===//
-// Affine Expressions, Affine Maps, and Integet Sets.
+// Affine Expressions, Affine Maps, and Integer Sets.
//===----------------------------------------------------------------------===//
AffineExpr Builder::getAffineDimExpr(unsigned position) {
: SourceMgrDiagnosticVerifierHandler(srcMgr, ctx, llvm::errs()) {}
SourceMgrDiagnosticVerifierHandler::~SourceMgrDiagnosticVerifierHandler() {
- // Ensure that all expected diagnosics were handled.
+ // Ensure that all expected diagnostics were handled.
(void)verify();
}
};
// If this instance is uniqued, then we handle it separately so that multiple
- // threads may simulatenously access existing instances.
+ // threads may simultaneously access existing instances.
if (constraints.size() < IntegerSet::kUniquingThreshold) {
auto key = std::make_tuple(dimCount, symbolCount, constraints, eqFlags);
return safeGetOrCreate(impl.integerSets, key, impl.affineMutex,
return op->emitOpError()
<< "Operations with a 'SymbolTable' must have exactly one region";
- // Check that all symboles are uniquely named within child regions.
+ // Check that all symbols are uniquely named within child regions.
llvm::StringMap<Location> nameToOrigLoc;
for (auto &block : op->getRegion(0)) {
for (auto &op : block) {
using llvm::SMLoc;
using llvm::SourceMgr;
-// Returns true if 'c' is an allowable puncuation character: [$._-]
+// Returns true if 'c' is an allowable punctuation character: [$._-]
// Returns false otherwise.
static bool isPunct(char c) {
return c == '$' || c == '.' || c == '_' || c == '-';
// Handle the hexadecimal case.
if (curPtr[-1] == '0' && *curPtr == 'x') {
- // If we see stuff like 0xi32, this is a literal `0` follwed by an
+ // If we see stuff like 0xi32, this is a literal `0` followed by an
// identifier `xi32`, stop after `0`.
if (!isxdigit(curPtr[1]))
return formToken(Token::integer, tokStart);
}
/// Parse the body of a pretty dialect symbol, which starts and ends with <>'s,
-/// and may be recursive. Return with the 'prettyName' StringRef encompasing
+/// and may be recursive. Return with the 'prettyName' StringRef encompassing
/// the entire pretty name.
///
/// pretty-dialect-sym-body ::= '<' pretty-dialect-sym-contents+ '>'
/// This keeps track of the block names as well as the location of the first
/// reference for each nested name scope. This is used to diagnose invalid
- /// block references and memoize them.
+ /// block references and memorize them.
SmallVector<DenseMap<StringRef, std::pair<Block *, SMLoc>>, 2> blocksByName;
SmallVector<DenseMap<Block *, SMLoc>, 2> forwardRef;
namespace {
// RAII-style guard for cleaning up the regions in the operation state before
// deleting them. Within the parser, regions may get deleted if parsing failed,
-// and other errors may be present, in praticular undominated uses. This makes
+// and other errors may be present, in particular undominated uses. This makes
// sure such uses are deleted.
struct CleanupOpStateRegions {
~CleanupOpStateRegions() {
return nullptr;
}
- // Add the sucessors, and their operands after the proper operands.
+ // Add the successors, and their operands after the proper operands.
for (const auto &succ : llvm::zip(successors, successorOperands)) {
Block *successor = std::get<0>(succ);
const SmallVector<Value *, 4> &operands = std::get<1>(succ);
//===--------------------------------------------------------------------===//
/// Parse a region that takes `arguments` of `argTypes` types. This
- /// effectively defines the SSA values of `arguments` and assignes their type.
+ /// effectively defines the SSA values of `arguments` and assigns their type.
ParseResult parseRegion(Region ®ion, ArrayRef<OperandType> arguments,
ArrayRef<Type> argTypes,
bool enableNameShadowing) override {
// Clear out any computed operation analyses. These analyses won't be used
// any more in this pipeline, and this helps reduce the current working set
// of memory. If preserving these analyses becomes important in the future
- // we can re-evalutate this.
+ // we can re-evaluate this.
am.clear();
return result;
}
.count());
}
- // Otheriwse, accumulate the timing from each of the children.
+ // Otherwise, accumulate the timing from each of the children.
TimeRecord totalTime;
for (auto &child : children)
totalTime += child.second->getTotalTime();
mergeChildren(std::move(other.children));
}
- /// Merge the timer chilren in 'otherChildren' with the children of this
+ /// Merge the timer children in 'otherChildren' with the children of this
/// timer.
void mergeChildren(ChildrenMap &&otherChildren) {
// Check for an empty children list.
}
// Pipeline merges are handled separately as the children are merged
- // lexographically.
+ // lexicographically.
if (kind == TimerKind::Pipeline) {
assert(children.size() == otherChildren.size() &&
"pipeline merge requires the same number of children");
double minOvershoot = boundingMin - adjMinMax.first;
// If undershooting on the min or max end, return that because it is
// to be unconditionally avoided. Otherwise return the end with the
- // greateast magnitude of overshoot.
+ // greatest magnitude of overshoot.
if (maxOvershoot < 0)
return maxOvershoot;
if (minOvershoot < 0)
for (auto it : *listInit) {
auto *dagInit = dyn_cast<llvm::DagInit>(it);
if (!dagInit)
- PrintFatalError(def.getLoc(), "all elemements in Pattern multi-entity "
+ PrintFatalError(def.getLoc(), "all elements in Pattern multi-entity "
"constraints should be DAG nodes");
std::vector<std::string> entities;
}
// If the current combined predicate is a leaf substitution, append it to the
- // list before contiuing.
+ // list before continuing.
auto allSubstitutions = llvm::to_vector<4>(substitutions);
if (rootNode->kind == PredCombinerKind::SubstLeaves) {
const auto &substPred = static_cast<const tblgen::SubstLeavesPred &>(root);
// TODO(zinenko,jpienaar): we can support ground truth for rewritten
// predicates by either (a) having our own unique'ing of the predicates
// instead of relying on TableGen record pointers or (b) taking ground truth
- // values optinally prefixed with a list of substitutions to apply, e.g.
+ // values optionally prefixed with a list of substitutions to apply, e.g.
// "predX is true by itself as well as predSubY leaf substitution had been
// applied to it".
if (node->kind == PredCombinerKind::SubstLeaves) {
// MemRefDependenceGraph is a graph data structure where graph nodes are
// top-level operations in a FuncOp which contain load/store ops, and edges
// are memref dependences between the nodes.
-// TODO(andydavis) Add a more flexible dependece graph representation.
+// TODO(andydavis) Add a more flexible dependence graph representation.
// TODO(andydavis) Add a depth parameter to dependence graph construction.
struct MemRefDependenceGraph {
public:
}
};
- // Edge represents a data dependece between nodes in the graph.
+ // Edge represents a data dependence between nodes in the graph.
struct Edge {
// The id of the node at the other end of the edge.
// If this edge is stored in Edge = Node.inEdges[i], then
void dump() const { print(llvm::errs()); }
};
-// Intializes the data dependence graph by walking operations in 'f'.
+// Initializes the data dependence graph by walking operations in 'f'.
// Assigns each node in the graph a node id based on program order in 'f'.
// TODO(andydavis) Add support for taking a Block arg to construct the
// dependence graph at a different depth.
"non-constant number of elts in local buffer");
const FlatAffineConstraints *cst = region.getConstraints();
- // 'outerIVs' holds the values that this memory region is symbolic/paramteric
+ // 'outerIVs' holds the values that this memory region is symbolic/parametric
// on; this would correspond to loop IVs surrounding the level at which the
// slice is being materialized.
SmallVector<Value *, 8> outerIVs;
// surrounding 'srcOpInst' into the loop nest surrounding 'dstLoadOpInsts'.
// The argument 'srcStoreOpInst' is used to calculate the storage reduction on
// the memref being produced and consumed, which is an input to the cost model.
-// For producer-constumer fusion, 'srcStoreOpInst' will be the same as
+// For producer-consumer fusion, 'srcStoreOpInst' will be the same as
// 'srcOpInst', as we are slicing w.r.t to that producer.
// For input-reuse fusion, 'srcOpInst' will be the src loop nest LoadOp which
// reads from the same memref as dst loop nest load ops, and 'srcStoreOpInst'
// nest).
// *) Computes the cost of fusing a slice of the src loop nest into the dst
// loop nest at various values of dst loop depth, attempting to fuse
-// the largest compution slice at the maximal dst loop depth (closest to the
-// load) to minimize reuse distance and potentially enable subsequent
+// the largest computation slice at the maximal dst loop depth (closest to
+// the load) to minimize reuse distance and potentially enable subsequent
// load/store forwarding.
// NOTE: If the dst loop nest includes multiple loads in 'dstLoadOpInsts' for
// the same memref as is written by 'srcOpInst', then the union of slice
// NOTE: We attempt to maximize the dst loop depth, but there are cases
// where a particular setting for 'dstLoopNest' might fuse an unsliced
// loop (within the src computation slice) at a depth which results in
-// execessive recomputation (see unit tests for examples).
+// excessive recomputation (see unit tests for examples).
// *) Compares the total cost of the unfused loop nests to the min cost fused
// loop nest computed in the previous step, and returns true if the latter
// is lower.
mdg->addEdge(newMemRefNodeId, dstId, newMemRef);
}
- // Collect dst loop stats after memref privatizaton transformation.
+ // Collect dst loop stats after memref privatization transformation.
LoopNestStateCollector dstLoopCollector;
dstLoopCollector.collect(dstAffineForOp.getOperation());
promoteIfSingleIteration(forOp);
}
- // Collect dst loop stats after memref privatizaton transformation.
+ // Collect dst loop stats after memref privatization transformation.
auto dstForInst = cast<AffineForOp>(dstNode->op);
LoopNestStateCollector dstLoopCollector;
dstLoopCollector.collect(dstForInst.getOperation());
if (!maybeExpandedMap)
return matchFailure();
- // Build std.store valutToStore, memref[expandedMap.results].
+ // Build std.store valueToStore, memref[expandedMap.results].
rewriter.replaceOpWithNewOp<StoreOp>(op, op.getValueToStore(),
op.getMemRef(), *maybeExpandedMap);
return matchSuccess();
// all store op's that have a dependence into the load, is provably the last
// writer to the particular memref location being loaded at the load op, and its
// store value can be forwarded to the load. Note that the only dependences
-// that are to be considered are those that are satisifed at the block* of the
+// that are to be considered are those that are satisfied at the block* of the
// innermost common surrounding loop of the <store, load> being considered.
//
// (* A dependence being satisfied at a block: a dependence that is satisfied by
// This method uses an algorithm// in time linear in the number of operations
// in the body of the for loop - (using the 'sweep line' paradigm). This method
// asserts preservation of SSA dominance. A check for that as well as that for
-// memory-based depedence preservation check rests with the users of this
+// memory-based dependence preservation check rests with the users of this
// method.
LogicalResult mlir::instBodySkew(AffineForOp forOp, ArrayRef<uint64_t> shifts,
bool unrollPrologueEpilogue) {
// Checks each dependence component against the permutation to see if the
// desired loop interchange would violate dependences by making the
-// dependence componenent lexicographically negative.
+// dependence component lexicographically negative.
static bool checkLoopInterchangeDependences(
const std::vector<llvm::SmallVector<DependenceComponent, 2>> &depCompsVec,
ArrayRef<AffineForOp> loops, ArrayRef<unsigned> loopPermMap) {
Loops mlir::tilePerfectlyNested(loop::ForOp rootForOp,
ArrayRef<Value *> sizes) {
- // Collect prefectly nested loops. If more size values provided than nested
+ // Collect perfectly nested loops. If more size values provided than nested
// loops available, truncate `sizes`.
SmallVector<loop::ForOp, 4> forOps;
forOps.reserve(sizes.size());
// Build the IR that performs ceil division of a positive value by a constant:
// ceildiv(a, B) = divis(a + (B-1), B)
-// where divis is roundning-to-zero division.
+// where divis is rounding-to-zero division.
static Value *ceilDivPositive(OpBuilder &builder, Location loc, Value *dividend,
int64_t divisor) {
assert(divisor > 0 && "expected positive divisor");
}
const FlatAffineConstraints *cst = region.getConstraints();
- // 'regionSymbols' hold values that this memory region is symbolic/paramteric
+ // 'regionSymbols' hold values that this memory region is symbolic/parametric
// on; these typically include loop IVs surrounding the level at which the
// copy generation is being done or other valid symbols in MLIR.
SmallVector<Value *, 8> regionSymbols;
/// programmer/library: we derive information from scalar code + annotations.
/// 2. After dependence analysis and before polyhedral scheduling: the
/// information that supports vectorization does not need to be supplied by a
-/// higher level of abstraction. Traditional dependence anaysis is available
+/// higher level of abstraction. Traditional dependence analysis is available
/// in MLIR and will be used to drive vectorization and cost models.
///
/// Let's pause here and remark that applying super-vectorization as described
/// operating on elemental vector types. For this reason, the pattern
/// profitability analysis should include a component that also captures the
/// maximal amount of fusion available under a particular pattern. This is
-/// still at the stage of rought ideas but in this context, search is our
+/// still at the stage of rough ideas but in this context, search is our
/// friend as the Tensor Comprehensions and auto-TVM contributions
/// demonstrated previously.
/// Bottom-line is we do not yet have good answers for the above but aim at
/// 1. defining super-vectorization patterns and matching them on the tree of
/// AffineForOp. A super-vectorization pattern is defined as a recursive
/// data structures that matches and captures nested, imperfectly-nested
-/// loops that have a. comformable loop annotations attached (e.g. parallel,
-/// reduction, vectoriable, ...) as well as b. all contiguous load/store
+/// loops that have a. conformable loop annotations attached (e.g. parallel,
+/// reduction, vectorizable, ...) as well as b. all contiguous load/store
/// operations along a specified minor dimension (not necessarily the
/// fastest varying) ;
/// 2. analyzing those patterns for profitability (TODO(ntv): and
/// --test-fastest-varying=1 --test-fastest-varying=0
/// ```
///
-/// produces this more insteresting mixed outer-innermost-loop vectorized code:
+/// produces this more interesting mixed outer-innermost-loop vectorized code:
/// ```mlir
/// mlfunc @vector_add_2d(%arg0 : index, %arg1 : index) -> f32 {
/// %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
/// Iterates over the forward slice from the loads in the vectorization pattern
/// and rewrites them using their vectorized counterpart by:
-/// 1. Create the forward slice starting from the laods in the vectorization
+/// 1. Create the forward slice starting from the loads in the vectorization
/// pattern.
/// 2. Topologically sorts the forward slice.
/// 3. For each operation in the slice, create the vector form of this
!type_rhs = type tensor<4x!quant.uniform<i8:f32, 3.875e-2>>
!type_result = type tensor<4x!quant.uniform<i8:f32, 1.065e-4>>
func @real_mulew_multiplier_gt_1(%arg0 : !type_lhs, %arg1: !type_rhs) -> !type_result {
- // expected-warning@+1 {{unimplemented: cannot multiply with multipler > 1.0}}
+ // expected-warning@+1 {{unimplemented: cannot multiply with multiplier > 1.0}}
%0 = "fxpmath.real_mul_ew"(%arg0, %arg1) : (!type_lhs, !type_rhs) -> (!type_result)
return %0 : !type_result
}
projects / platform / upstream / llvm.git / commitdiff