Please use GitHub pull requests for new patches. Phabricator shutdown timeline

Differential D110896 Diff 391806 mlir/lib/Transforms/Utils/DialectConversion.cpp

Changeset View

Standalone View

View Options

mlir/lib/Transforms/Utils/DialectConversion.cpp

Show First 20 Lines • Show All 845 Lines • ▼ Show 20 Lines

}

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

// ConversionPatternRewriterImpl

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

namespace mlir {

namespace detail {

struct ConversionPatternRewriterImpl {

ConversionPatternRewriterImpl(PatternRewriter &rewriter)

explicit ConversionPatternRewriterImpl(PatternRewriter &rewriter)

: argConverter(rewriter, unresolvedMaterializations) {}

: argConverter(rewriter, unresolvedMaterializations),

notifyCallback(nullptr) {}

/// Cleanup and destroy any generated rewrite operations. This method is

/// invoked when the conversion process fails.

void discardRewrites();

/// Apply all requested operation rewrites. This method is invoked when the

/// conversion process succeeds.

void applyRewrites();

▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines

struct ConversionPatternRewriterImpl {

/// with values with different result types than the original operation, e.g.

/// 1->N conversion of some kind.

SmallVector<unsigned, 4> operationsWithChangedResults;

/// The current type converter, or nullptr if no type converter is currently

/// active.

TypeConverter *currentTypeConverter = nullptr;

/// This allows the user to collect the match failure message.

function_ref<void(Diagnostic &)> notifyCallback;

#ifndef NDEBUG

/// A set of operations that have pending updates. This tracking isn't

/// strictly necessary, and is thus only active during debug builds for extra

/// verification.

SmallPtrSet<Operation *, 1> pendingRootUpdates;

/// A logger used to emit diagnostics during the conversion process.

llvm::ScopedPrinter logger{llvm::dbgs()};

▲ Show 20 Lines • Show All 451 Lines • ▼ Show 20 Lines

void ConversionPatternRewriterImpl::notifyRegionWasClonedBefore(

// This original region has already had its conversion set computed, so there

// shouldn't be any new failures.

(void)result;

assert(succeeded(result) && "expected region to have no unreachable blocks");

}

LogicalResult ConversionPatternRewriterImpl::notifyMatchFailure(

Location loc, function_ref<void(Diagnostic &)> reasonCallback) {

LLVM_DEBUG({

rriddleUnsubmitted

Not Done

This isn't the same as LLVM_DEBUG. LLVM_DEBUG also handles checking if the current debug mode enabled is dialect conversion. Can we just have a bool that is defaulted to true/false depending on notifyCallback, that gets explicitly set to true inside of an LLVM_DEBUG code block?

rriddle: This isn't the same as LLVM_DEBUG. LLVM_DEBUG also handles checking if the current debug mode…

Chia-hungDuanAuthorUnsubmitted

Done

Reverted back to use LLVM_DEBUG I think that's enough for the initial support

Chia-hungDuan: Reverted back to use LLVM_DEBUG I think that's enough for the initial support

Diagnostic diag(loc, DiagnosticSeverity::Remark);

reasonCallback(diag);

logger.startLine() << "** Failure : " << diag.str() << "\n";

if (notifyCallback)

notifyCallback(diag);

});

return failure();

}

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

// ConversionPatternRewriter

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

ConversionPatternRewriter::ConversionPatternRewriter(MLIRContext *ctx)

: PatternRewriter(ctx),

impl(new detail::ConversionPatternRewriterImpl(*this)) {}

ConversionPatternRewriter::~ConversionPatternRewriter() {}

void ConversionPatternRewriter::replaceOpWithIf(

Operation *op, ValueRange newValues, bool *allUsesReplaced,

llvm::unique_function<bool(OpOperand &) const> functor) {

rriddleUnsubmitted

Not Done

return failure();

}

void ConversionPatternRewriterImpl::setNotifyCallback(

function_ref<void(Diagnostic &)> callback) {

notifyCallback = callback;

}

bool ConversionPatternRewriterImpl::hasNotifyCallback() const {

- return notifyCallback ? true : false;

+ return notifyCallback;

}

void ConversionPatternRewriterImpl::notifyMatchResult(Diagnostic &diag) {

notifyCallback(diag);

}

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

nit: I would just inline all of these into the class.

rriddle: nit: I would just inline all of these into the class.

// TODO: To support this we will need to rework a bit of how replacements are

// tracked, given that this isn't guranteed to replace all of the uses of an

// operation. The main change is that now an operation can be replaced

// multiple times, in parts. The current "set" based tracking is mainly useful

// for tracking if a replaced operation should be ignored, i.e. if all of the

// uses will be replaced.

llvm_unreachable(

"replaceOpWithIf is currently not supported by DialectConversion");

▲ Show 20 Lines • Show All 442 Lines • ▼ Show 20 Lines

OperationLegalizer::legalizeWithPattern(Operation *op,

// Functor that returns if the given pattern may be applied.

auto canApply = [&](const Pattern &pattern) {

return canApplyPattern(op, pattern, rewriter);

};

// Functor that cleans up the rewriter state after a pattern failed to match.

RewriterState curState = rewriterImpl.getCurrentState();

auto onFailure = [&](const Pattern &pattern) {

LLVM_DEBUG(logFailure(rewriterImpl.logger, "pattern failed to match"));

LLVM_DEBUG({

logFailure(rewriterImpl.logger, "pattern failed to match");

if (rewriterImpl.notifyCallback) {

Diagnostic diag(op->getLoc(), DiagnosticSeverity::Remark);

diag << "Failed to apply pattern \"" << pattern.getDebugName()

<< "\" on op:\n"

<< *op;

rewriterImpl.notifyCallback(diag);

rriddleUnsubmitted

Not Done

What does the pattern debug log output look like with this?

rriddle: What does the pattern debug log output look like with this?

Chia-hungDuanAuthorUnsubmitted

Done

As you mentioned, the curly brackets may have little problem. Added a new line for output. Now it looks like

Failed to apply pattern "(anonymous namespace)::TestRegionRewriteBlockMovement" on op:
"test.region"() ( {
^bb0(%arg0: i64):  // no predecessors
  br ^bb1(%arg0 : i64)
^bb1(%0: i64):  // pred: ^bb0
  "test.invalid"(%0) : (i64) -> ()
}) {legalizer.erase_old_blocks, legalizer.should_clone} : () -> ()

Chia-hungDuan: As you mentioned, the curly brackets may have little problem. Added a new line for output. Now…

}

});

rewriterImpl.resetState(curState);

appliedPatterns.erase(&pattern);

};

// Functor that performs additional legalization when a pattern is

// successfully applied.

auto onSuccess = [&](const Pattern &pattern) {

auto result = legalizePatternResult(op, pattern, rewriter, curState);

▲ Show 20 Lines • Show All 367 Lines • ▼ Show 20 Lines

struct OperationConverter {

explicit OperationConverter(ConversionTarget &target,

const FrozenRewritePatternSet &patterns,

OpConversionMode mode,

DenseSet<Operation *> *trackedOps = nullptr)

: opLegalizer(target, patterns), mode(mode), trackedOps(trackedOps) {}

/// Converts the given operations to the conversion target.

LogicalResult convertOperations(ArrayRef<Operation *> ops);

LogicalResult

convertOperations(ArrayRef<Operation *> ops,

function_ref<void(Diagnostic &)> notifyCallback = nullptr);

private:

/// Converts an operation with the given rewriter.

LogicalResult convert(ConversionPatternRewriter &rewriter, Operation *op);

/// This method is called after the conversion process to legalize any

/// remaining artifacts and complete the conversion.

LogicalResult finalize(ConversionPatternRewriter &rewriter);

▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines

if (failed(opLegalizer.legalize(op, rewriter))) {

// Analysis conversions don't fail if any operations fail to legalize,

// they are only interested in the operations that were successfully

// legalized.

trackedOps->insert(op);

}

return success();

}

LogicalResult OperationConverter::convertOperations(ArrayRef<Operation *> ops) {

LogicalResult OperationConverter::convertOperations(

ArrayRef<Operation *> ops,

function_ref<void(Diagnostic &)> notifyCallback) {

if (ops.empty())

return success();

ConversionTarget &target = opLegalizer.getTarget();

// Compute the set of operations and blocks to convert.

SmallVector<Operation *> toConvert;

for (auto *op : ops) {

toConvert.emplace_back(op);

for (auto &region : op->getRegions())

if (failed(computeConversionSet(region.getBlocks(), region.getLoc(),

toConvert, &target)))

return failure();

}

// Convert each operation and discard rewrites on failure.

ConversionPatternRewriter rewriter(ops.front()->getContext());

ConversionPatternRewriterImpl &rewriterImpl = rewriter.getImpl();

rewriterImpl.notifyCallback = notifyCallback;

for (auto *op : toConvert)

if (failed(convert(rewriter, op)))

return rewriterImpl.discardRewrites(), failure();

// Now that all of the operations have been converted, finalize the conversion

// process to ensure any lingering conversion artifacts are cleaned up and

// legalized.

if (failed(finalize(rewriter)))

▲ Show 20 Lines • Show All 831 Lines • ▼ Show 20 Lines

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

// Analysis Conversion

LogicalResult

mlir::applyAnalysisConversion(ArrayRef<Operation *> ops,

ConversionTarget &target,

const FrozenRewritePatternSet &patterns,

DenseSet<Operation *> &convertedOps) {

DenseSet<Operation *> &convertedOps,

function_ref<void(Diagnostic &)> notifyCallback) {

OperationConverter opConverter(target, patterns, OpConversionMode::Analysis,

&convertedOps);

return opConverter.convertOperations(ops);

return opConverter.convertOperations(ops, notifyCallback);

}

LogicalResult

mlir::applyAnalysisConversion(Operation *op, ConversionTarget &target,

const FrozenRewritePatternSet &patterns,

DenseSet<Operation *> &convertedOps) {

DenseSet<Operation *> &convertedOps,

function_ref<void(Diagnostic &)> notifyCallback) {

return applyAnalysisConversion(llvm::makeArrayRef(op), target, patterns,

convertedOps);

convertedOps, notifyCallback);

}