This is an archive of the discontinued LLVM Phabricator instance.

mlir/lib/Transforms/ViewOpGraph.cpp
162–163	Can we change these std::string params to Twine/StringRef?
244–251
245
247	Is the `->` here necessary?
248	Please add a comment for constant params with the name of the parameter
272	Same here, why the `->`?
276	Do you need to convert to std::string here? Or can you use Twine?

Thanks for the patch!

Is the intention to remove the need for ViewRegionGraph?

springerm marked 5 inline comments as done.Jul 22 2021, 11:03 PM

springerm added inline comments.

mlir/lib/Transforms/ViewOpGraph.cpp
162–163	Twines are used to avoid constructing temporary std::string, right? If so, `AttributeMap` should also be changed from `StringMap<std::string>` to `StringMap<Twine>`, but that's not possible because Twine's `operator=` is deleted. Also, the `label` will immediately be passed into `escapeString`, which requires converting it into an `std::string` again. With this in mind, is there actually any benefit of using `Twine` here?
276	The question is whether `emitEdgeStmt` should take an std::string or a Twine. See comment above, will change all callers of `emitEdgeStmt` accordingly.

address comments

In D106342#2897109, @rriddle wrote:

Thanks for the patch!

Is the intention to remove the need for ViewRegionGraph?

I didn't know that we have ViewRegionGraph. I think this commit would make it obsolete, as it seems to do the same thing (drawing a CFG).

Harbormaster completed remote builds in B115780: Diff 361092.Jul 22 2021, 11:19 PM

Can you provide an example of what the output here looks like compared to ViewRegionGraph? If it is close enough, I'd just delete ViewRegionGraph.

In D106342#2901858, @rriddle wrote:

Can you provide an example of what the output here looks like compared to ViewRegionGraph? If it is close enough, I'd just delete ViewRegionGraph.

The output of ViewRegionGraph doesn't seem very useful....

The new output looks much better IMO. As a final test (you don't have to upload this one), can you check that it produces something reasonable on a larger function? says thousands/low tens of thousands of ops? I've produced CFG dot graphs in LLVM for functions like that, and they get quite large. If the output is even semi reasonable at that scale, we should delete ViewRegionGraph.

mlir/include/mlir/Transforms/Passes.td
688–699	This description likely needs an update.
706–709	It isn't obvious to me that control flow edges should be off by default, I'd say that is more a matter of which dialect you are in. What is the downside to having it always enabled?
mlir/lib/Transforms/ViewOpGraph.cpp
162–163	If it is being converted to std::string anyways, that is fine. The one nice benefit of Twine though, is that it results in a single std::string creation instead of potentially multiple (depending on what the user does). (Also, I didn't read the code that far, seeing `std::string` in an LLVM code base is just a code smell)

This revision is now accepted and ready to land.Jul 23 2021, 10:59 PM

springerm marked an inline comment as done.Jul 24 2021, 4:39 AM

springerm added inline comments.

mlir/include/mlir/Transforms/Passes.td
706–709	I had them enabled by default, but some guys from a hardware team said that the CFG edges were confusing to them. They are working with TF graphs (or some lowering thereof), so they didn't really need them. I have also seen cases where a constant is defined at the beginning of a function and then used further down. Having both data flow and control flow edges at the same time lead to a quite unreadable rendering with very long edges. Which one you want (control/data flow) depends on the dialect I guess... But I think the default should be either data flow or control flow.

minor update

Harbormaster completed remote builds in B116021: Diff 361437.Jul 24 2021, 4:56 AM

rebase

Herald added subscribers: wrengr, Chia-hungDuan. · View Herald TranscriptAug 3 2021, 7:01 PM

rebase

Harbormaster completed remote builds in B117796: Diff 363940.Aug 3 2021, 7:24 PM

rebase

Harbormaster completed remote builds in B117799: Diff 363943.Aug 3 2021, 7:37 PM

update

Herald added a subscriber: mgorny. · View Herald TranscriptAug 4 2021, 1:38 AM

Harbormaster completed remote builds in B117839: Diff 364002.Aug 4 2021, 1:57 AM

rebase

Harbormaster completed remote builds in B117867: Diff 364042.Aug 4 2021, 4:29 AM

This revision was landed with ongoing or failed builds.Aug 4 2021, 4:45 AM

Closed by commit rG9102a16bef1a: [mlir] Support drawing control-flow graphs in ViewOpGraph.cpp (authored by springerm). · Explain Why

This revision was automatically updated to reflect the committed changes.

springerm added a commit: rG9102a16bef1a: [mlir] Support drawing control-flow graphs in ViewOpGraph.cpp.

springerm mentioned this in D107451: [mlir] Include llvm/Support/Debug.h in Transforms/Passes.h.Aug 4 2021, 5:37 AM

springerm mentioned this in rGb6408fa169d6: [mlir] Include llvm/Support/Debug.h in Transforms/Passes.h.Aug 4 2021, 5:47 AM

springerm mentioned this in D107517: [mlir] Update comment in Region.h.Aug 4 2021, 5:51 PM

springerm mentioned this in rGac7c7cbfdaf9: [mlir] Update comment in Region.h.Aug 4 2021, 6:58 PM

Revision Contents

Path

Size

mlir/

include/

mlir/

Transforms/

Passes.h

1 line

Passes.td

18 lines

ViewRegionGraph.h

lib/

Transforms/

1 line

1 line

61 lines

test/

Transforms/

print-op-graph.mlir

73 lines

Diff 364046

mlir/include/mlir/Transforms/Passes.h

	Show All 11 Lines
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#ifndef MLIR_TRANSFORMS_PASSES_H			#ifndef MLIR_TRANSFORMS_PASSES_H
	#define MLIR_TRANSFORMS_PASSES_H			#define MLIR_TRANSFORMS_PASSES_H

	#include "mlir/Pass/Pass.h"			#include "mlir/Pass/Pass.h"
	#include "mlir/Transforms/LocationSnapshot.h"			#include "mlir/Transforms/LocationSnapshot.h"
	#include "mlir/Transforms/ViewOpGraph.h"			#include "mlir/Transforms/ViewOpGraph.h"
	#include "mlir/Transforms/ViewRegionGraph.h"
	#include <limits>			#include <limits>

	namespace mlir {			namespace mlir {

	class AffineForOp;			class AffineForOp;
	class GreedyRewriteConfig;			class GreedyRewriteConfig;

	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

mlir/include/mlir/Transforms/Passes.td

Show First 20 Lines • Show All 606 Lines • ▼ Show 20 Lines	ListOption<"clCollapsedIndices1", "collapsed-indices-1", "unsigned",
"Which loop indices to combine into the position 1 loop index",		"Which loop indices to combine into the position 1 loop index",
"llvm::cl::MiscFlags::CommaSeparated">,		"llvm::cl::MiscFlags::CommaSeparated">,
ListOption<"clCollapsedIndices2", "collapsed-indices-2", "unsigned",		ListOption<"clCollapsedIndices2", "collapsed-indices-2", "unsigned",
"Which loop indices to combine into the position 2 loop index",		"Which loop indices to combine into the position 2 loop index",
"llvm::cl::MiscFlags::CommaSeparated">,		"llvm::cl::MiscFlags::CommaSeparated">,
];		];
}		}

def PrintCFG : FunctionPass<"print-cfg-graph"> {
let summary = "Print CFG graph per-Region";
let constructor = "mlir::createPrintCFGGraphPass()";
}

def PrintOpStats : Pass<"print-op-stats"> {		def PrintOpStats : Pass<"print-op-stats"> {
let summary = "Print statistics of operations";		let summary = "Print statistics of operations";
let constructor = "mlir::createPrintOpStatsPass()";		let constructor = "mlir::createPrintOpStatsPass()";
}		}

def SCCP : Pass<"sccp"> {		def SCCP : Pass<"sccp"> {
let summary = "Sparse Conditional Constant Propagation";		let summary = "Sparse Conditional Constant Propagation";
let description = [{		let description = [{
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines	let description = [{

See [Symbols and SymbolTables](SymbolsAndSymbolTables.md) for more		See [Symbols and SymbolTables](SymbolsAndSymbolTables.md) for more
information on `Symbols`.		information on `Symbols`.
}];		}];
let constructor = "mlir::createSymbolDCEPass()";		let constructor = "mlir::createSymbolDCEPass()";
}		}

def ViewOpGraphPass : Pass<"view-op-graph"> {		def ViewOpGraphPass : Pass<"view-op-graph"> {
let summary = "Print Graphviz dataflow visualization of an operation";		let summary = "Print Graphviz visualization of an operation";
let description = [{		let description = [{
This pass prints a Graphviz dataflow graph of a module.		This pass prints a Graphviz graph of a module.

- Operations are represented as nodes;		- Operations are represented as nodes;
- Uses as edges;		- Uses (data flow) as edges;
		- Control flow as dashed edges;
- Regions/blocks as subgraphs.		- Regions/blocks as subgraphs.

		By default, only data flow edges are printed.

Note: See https://www.graphviz.org/doc/info/lang.html for more information		Note: See https://www.graphviz.org/doc/info/lang.html for more information
about the Graphviz DOT language.		about the Graphviz DOT language.
		rriddleUnsubmitted Done Reply Inline Actions This description likely needs an update. rriddle: This description likely needs an update.
}];		}];
let options = [		let options = [
Option<"maxLabelLen", "max-label-len", "unsigned",		Option<"maxLabelLen", "max-label-len", "unsigned",
/default=/"20", "Limit attribute/type length to number of chars">,		/default=/"20", "Limit attribute/type length to number of chars">,
Option<"printAttrs", "print-attrs", "bool",		Option<"printAttrs", "print-attrs", "bool",
/default=/"true", "Print attributes of operations">,		/default=/"true", "Print attributes of operations">,
		Option<"printControlFlowEdges", "print-control-flow-edges", "bool",
		/default=/"false", "Print control flow edges">,
		Option<"printDataFlowEdges", "print-data-flow-edges", "bool",
		/default=/"true", "Print data flow edges">,
		rriddleUnsubmitted Not Done Reply Inline Actions It isn't obvious to me that control flow edges should be off by default, I'd say that is more a matter of which dialect you are in. What is the downside to having it always enabled? rriddle: It isn't obvious to me that control flow edges should be off by default, I'd say that is more a…
		springermAuthorUnsubmitted Done Reply Inline Actions I had them enabled by default, but some guys from a hardware team said that the CFG edges were confusing to them. They are working with TF graphs (or some lowering thereof), so they didn't really need them. I have also seen cases where a constant is defined at the beginning of a function and then used further down. Having both data flow and control flow edges at the same time lead to a quite unreadable rendering with very long edges. Which one you want (control/data flow) depends on the dialect I guess... But I think the default should be either data flow or control flow. springerm: I had them enabled by default, but some guys from a hardware team said that the CFG edges were…
Option<"printResultTypes", "print-result-types", "bool",		Option<"printResultTypes", "print-result-types", "bool",
/default=/"true", "Print result types of operations">		/default=/"true", "Print result types of operations">
];		];
let constructor = "mlir::createPrintOpGraphPass()";		let constructor = "mlir::createPrintOpGraphPass()";
}		}

#endif // MLIR_TRANSFORMS_PASSES		#endif // MLIR_TRANSFORMS_PASSES

mlir/include/mlir/Transforms/ViewRegionGraph.h

This file was deleted.

	//===- ViewRegionGraph.h - View/write graphviz graphs ------------ 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
	//
	//===----------------------------------------------------------------------===//
	//
	// Defines interface to produce Graphviz outputs of MLIR Regions.
	//
	//===----------------------------------------------------------------------===//

	#ifndef MLIR_TRANSFORMS_VIEWFUNCTIONGRAPH_H_
	#define MLIR_TRANSFORMS_VIEWFUNCTIONGRAPH_H_

	#include "mlir/Support/LLVM.h"
	#include "llvm/Support/GraphWriter.h"
	#include "llvm/Support/raw_ostream.h"

	namespace mlir {
	class FuncOp;
	template <typename T> class OperationPass;
	class Region;

	/// Displays the CFG in a window. This is for use from the debugger and
	/// depends on Graphviz to generate the graph.
	void viewGraph(Region &region, const Twine &name, bool shortNames = false,
	const Twine &title = "",
	llvm::GraphProgram::Name program = llvm::GraphProgram::DOT);

	raw_ostream &writeGraph(raw_ostream &os, Region &region,
	bool shortNames = false, const Twine &title = "");

	/// Creates a pass to print CFG graphs.
	std::unique_ptr<mlir::OperationPass<mlir::FuncOp>>
	createPrintCFGGraphPass(raw_ostream &os = llvm::errs(), bool shortNames = false,
	const Twine &title = "");

	} // end namespace mlir

	#endif // MLIR_TRANSFORMS_VIEWFUNCTIONGRAPH_H_

mlir/lib/Transforms/CMakeLists.txt

Show All 15 Lines	add_mlir_library(MLIRTransforms
NormalizeMemRefs.cpp		NormalizeMemRefs.cpp
OpStats.cpp		OpStats.cpp
ParallelLoopCollapsing.cpp		ParallelLoopCollapsing.cpp
PipelineDataTransfer.cpp		PipelineDataTransfer.cpp
SCCP.cpp		SCCP.cpp
StripDebugInfo.cpp		StripDebugInfo.cpp
SymbolDCE.cpp		SymbolDCE.cpp
ViewOpGraph.cpp		ViewOpGraph.cpp
ViewRegionGraph.cpp

ADDITIONAL_HEADER_DIRS		ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Transforms		${MLIR_MAIN_INCLUDE_DIR}/mlir/Transforms

DEPENDS		DEPENDS
MLIRStandardOpsIncGen		MLIRStandardOpsIncGen
MLIRTransformsPassIncGen		MLIRTransformsPassIncGen

Show All 13 Lines

mlir/lib/Transforms/NormalizeMemRefs.cpp

	Show All 11 Lines
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "PassDetail.h"			#include "PassDetail.h"
	#include "mlir/Dialect/Affine/IR/AffineOps.h"			#include "mlir/Dialect/Affine/IR/AffineOps.h"
	#include "mlir/Dialect/MemRef/IR/MemRef.h"			#include "mlir/Dialect/MemRef/IR/MemRef.h"
	#include "mlir/Transforms/Passes.h"			#include "mlir/Transforms/Passes.h"
	#include "mlir/Transforms/Utils.h"			#include "mlir/Transforms/Utils.h"
	#include "llvm/ADT/SmallSet.h"			#include "llvm/ADT/SmallSet.h"
				#include "llvm/Support/Debug.h"

	#define DEBUG_TYPE "normalize-memrefs"			#define DEBUG_TYPE "normalize-memrefs"

	using namespace mlir;			using namespace mlir;

	namespace {			namespace {

	/// All memrefs passed across functions with non-trivial layout maps are			/// All memrefs passed across functions with non-trivial layout maps are
	▲ Show 20 Lines • Show All 496 Lines • Show Last 20 Lines

mlir/lib/Transforms/ViewOpGraph.cpp

//===- ViewOpGraph.cpp - View/write op graphviz graphs --------------------===// //===- ViewOpGraph.cpp - View/write op graphviz graphs --------------------===//

// //

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

// //

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

#include "mlir/Transforms/ViewOpGraph.h" #include "mlir/Transforms/ViewOpGraph.h"

#include "PassDetail.h" #include "PassDetail.h"

#include "mlir/IR/Block.h" #include "mlir/IR/Block.h"

#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"

#include "mlir/Support/IndentedOstream.h" #include "mlir/Support/IndentedOstream.h"

#include "llvm/Support/Format.h" #include "llvm/Support/Format.h"

#include "llvm/Support/GraphWriter.h"

using namespace mlir; using namespace mlir;

static const StringRef kLineStyleControlFlow = "dashed";

static const StringRef kLineStyleDataFlow = "solid"; static const StringRef kLineStyleDataFlow = "solid";

static const StringRef kShapeNode = "ellipse"; static const StringRef kShapeNode = "ellipse";

static const StringRef kShapeNone = "plain"; static const StringRef kShapeNone = "plain";

/// Return the size limits for eliding large attributes. /// Return the size limits for eliding large attributes.

static int64_t getLargeAttributeSizeLimit() { static int64_t getLargeAttributeSizeLimit() {

// Use the default from the printer flags if possible. // Use the default from the printer flags if possible.

if (Optional<int64_t> limit = OpPrintingFlags().getLargeElementsAttrLimit()) if (Optional<int64_t> limit = OpPrintingFlags().getLargeElementsAttrLimit())

▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines public:

void runOnOperation() override { void runOnOperation() override {

emitGraph([&]() { emitGraph([&]() {

processOperation(getOperation()); processOperation(getOperation());

emitAllEdgeStmts(); emitAllEdgeStmts();

}); });

} }

/// Create a CFG graph for a region. Used in `Region::viewGraph`.

void emitRegionCFG(Region &region) {

printControlFlowEdges = true;

printDataFlowEdges = false;

emitGraph([&]() { processRegion(region); });

}

private: private:

/// Emit all edges. This function should be called after all nodes have been /// Emit all edges. This function should be called after all nodes have been

/// emitted. /// emitted.

void emitAllEdgeStmts() { void emitAllEdgeStmts() {

for (const std::string &edge : edges) for (const std::string &edge : edges)

os << edge << ";\n"; os << edge << ";\n";

edges.clear(); edges.clear();

} }

▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines void emitMlirAttr(raw_ostream &os, Attribute attr) {

// Print all other attributes. // Print all other attributes.

std::string buf; std::string buf;

llvm::raw_string_ostream ss(buf); llvm::raw_string_ostream ss(buf);

attr.print(ss); attr.print(ss);

os << truncateString(ss.str()); os << truncateString(ss.str());

} }

/// Append an edge to the list of edges. /// Append an edge to the list of edges.

/// Note: Edges are written to the output stream via `emitAllEdgeStmts`. /// Note: Edges are written to the output stream via `emitAllEdgeStmts`.

void emitEdgeStmt(Node n1, Node n2, std::string label, void emitEdgeStmt(Node n1, Node n2, std::string label, StringRef style) {

rriddleUnsubmitted

Not Done

Can we change these std::string params to Twine/StringRef?

rriddle: Can we change these std::string params to Twine/StringRef?

springermAuthorUnsubmitted

Done

Twines are used to avoid constructing temporary std::string, right? If so, AttributeMap should also be changed from StringMap<std::string> to StringMap<Twine>, but that's not possible because Twine's operator= is deleted.

Also, the label will immediately be passed into escapeString, which requires converting it into an std::string again. With this in mind, is there actually any benefit of using Twine here?

springerm: Twines are used to avoid constructing temporary std::string, right? If so, `AttributeMap`…

rriddleUnsubmitted

Not Done

If it is being converted to std::string anyways, that is fine. The one nice benefit of Twine though, is that it results in a single std::string creation instead of potentially multiple (depending on what the user does).

(Also, I didn't read the code that far, seeing std::string in an LLVM code base is just a code smell)

rriddle: If it is being converted to std::string anyways, that is fine. The one nice benefit of Twine…

StringRef style = kLineStyleDataFlow) {

AttributeMap attrs; AttributeMap attrs;

attrs["style"] = style.str(); attrs["style"] = style.str();

// Do not label edges that start/end at a cluster boundary. Such edges are // Do not label edges that start/end at a cluster boundary. Such edges are

// clipped at the boundary, but labels are not. This can lead to labels // clipped at the boundary, but labels are not. This can lead to labels

// floating around without any edge next to them. // floating around without any edge next to them.

if (!n1.clusterId && !n2.clusterId) if (!n1.clusterId && !n2.clusterId)

attrs["label"] = quoteString(escapeString(label)); attrs["label"] = quoteString(escapeString(label));

// Use `ltail` and `lhead` to draw edges between clusters. // Use `ltail` and `lhead` to draw edges between clusters.

▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines private:

/// Process a block. Emit a cluster and one node per block argument and /// Process a block. Emit a cluster and one node per block argument and

/// operation inside the cluster. /// operation inside the cluster.

void processBlock(Block &block) { void processBlock(Block &block) {

emitClusterStmt([&]() { emitClusterStmt([&]() {

for (BlockArgument &blockArg : block.getArguments()) for (BlockArgument &blockArg : block.getArguments())

valueToNode[blockArg] = emitNodeStmt(getLabel(blockArg)); valueToNode[blockArg] = emitNodeStmt(getLabel(blockArg));

// Emit a node for each operation. // Emit a node for each operation.

for (Operation &op : block) Optional<Node> prevNode;

processOperation(&op); for (Operation &op : block) {

rriddleUnsubmitted

Done

Optional<Node> prevNode = llvm::None;

- for (auto &op : block.getOperations()) {

+ for (Operation &op : block) {

Node nextNode = processOperation(&op);

rriddle:

Node nextNode = processOperation(&op);

if (printControlFlowEdges && prevNode)

rriddleUnsubmitted

Done

Is the -> here necessary?

rriddle: Is the `->` here necessary?

emitEdgeStmt(*prevNode, nextNode, /*label=*/"",

rriddleUnsubmitted

Done

if (this->printControlFlowEdges && prevNode)

- emitEdgeStmt(*prevNode, nextNode, "", kLineStyleControlFlow);

+ emitEdgeStmt(*prevNode, nextNode, /*<param-name>=*/"", kLineStyleControlFlow);

prevNode = nextNode;

Please add a comment for constant params with the name of the parameter

rriddle: Please add a comment for constant params with the name of the parameter

kLineStyleControlFlow);

prevNode = nextNode;

}

rriddleUnsubmitted

Done

// Emit a node for each operation.

- Optional<Node> prevNode = llvm::None;

+ Optional<Node> prevNode;

for (auto &op : block.getOperations()) {

rriddle:

}); });

} }

/// Process an operation. If the operation has regions, emit a cluster. /// Process an operation. If the operation has regions, emit a cluster.

/// Otherwise, emit a node. /// Otherwise, emit a node.

void processOperation(Operation *op) { Node processOperation(Operation *op) {

Node node; Node node;

if (op->getNumRegions() > 0) { if (op->getNumRegions() > 0) {

// Emit cluster for op with regions. // Emit cluster for op with regions.

node = emitClusterStmt( node = emitClusterStmt(

[&]() { [&]() {

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

processRegion(region); processRegion(region);

}, },

getLabel(op)); getLabel(op));

} else { } else {

node = emitNodeStmt(getLabel(op)); node = emitNodeStmt(getLabel(op));

} }

// Insert edges originating from each operand. // Insert data flow edges originating from each operand.

if (printDataFlowEdges) {

rriddleUnsubmitted

Done

Same here, why the ->?

rriddle: Same here, why the `->`?

unsigned numOperands = op->getNumOperands(); unsigned numOperands = op->getNumOperands();

for (unsigned i = 0; i < numOperands; i++) for (unsigned i = 0; i < numOperands; i++)

emitEdgeStmt(valueToNode[op->getOperand(i)], node, emitEdgeStmt(valueToNode[op->getOperand(i)], node,

/*label=*/numOperands == 1 ? "" : std::to_string(i)); /*label=*/numOperands == 1 ? "" : std::to_string(i),

rriddleUnsubmitted

Not Done

Do you need to convert to std::string here? Or can you use Twine?

rriddle: Do you need to convert to std::string here? Or can you use Twine?

springermAuthorUnsubmitted

Done

The question is whether emitEdgeStmt should take an std::string or a Twine. See comment above, will change all callers of emitEdgeStmt accordingly.

springerm: The question is whether `emitEdgeStmt` should take an std::string or a Twine. See comment above…

kLineStyleDataFlow);

}

for (Value result : op->getResults()) for (Value result : op->getResults())

valueToNode[result] = node; valueToNode[result] = node;

return node;

} }

/// Process a region. /// Process a region.

void processRegion(Region &region) { void processRegion(Region &region) {

for (Block &block : region.getBlocks()) for (Block &block : region.getBlocks())

processBlock(block); processBlock(block);

} }

Show All 16 Lines

}; };

} // namespace } // namespace

std::unique_ptr<Pass> std::unique_ptr<Pass>

mlir::createPrintOpGraphPass(raw_ostream &os) { mlir::createPrintOpGraphPass(raw_ostream &os) {

return std::make_unique<PrintOpPass>(os); return std::make_unique<PrintOpPass>(os);

} }

/// Generate a CFG for a region and show it in a window.

static void llvmViewGraph(Region &region, const Twine &name) {

int fd;

std::string filename = llvm::createGraphFilename(name.str(), fd);

{

llvm::raw_fd_ostream os(fd, /*shouldClose=*/true);

if (fd == -1) {

llvm::errs() << "error opening file '" << filename << "' for writing\n";

return;

}

PrintOpPass pass(os);

pass.emitRegionCFG(region);

}

llvm::DisplayGraph(filename, /*wait=*/false, llvm::GraphProgram::DOT);

}

void mlir::Region::viewGraph(const Twine &regionName) {

llvmViewGraph(*this, regionName);

}

void mlir::Region::viewGraph() { viewGraph("region"); }

mlir/lib/Transforms/ViewRegionGraph.cpp

This file was deleted.

	//===- ViewRegionGraph.cpp - View/write graphviz graphs -------------------===//
	//
	// 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
	//
	//===----------------------------------------------------------------------===//

	#include "mlir/Transforms/ViewRegionGraph.h"
	#include "PassDetail.h"
	#include "mlir/IR/RegionGraphTraits.h"

	using namespace mlir;

	namespace llvm {

	// Specialize DOTGraphTraits to produce more readable output.
	template <> struct DOTGraphTraits<Region *> : public DefaultDOTGraphTraits {
	using DefaultDOTGraphTraits::DefaultDOTGraphTraits;

	static std::string getNodeLabel(Block Block, Region );
	};

	std::string DOTGraphTraits<Region >::getNodeLabel(Block Block, Region *) {
	// Reuse the print output for the node labels.
	std::string outStreamStr;
	raw_string_ostream os(outStreamStr);
	Block->print(os);
	std::string &outStr = os.str();

	if (outStr[0] == '\n')
	outStr.erase(outStr.begin());

	// Process string output to left justify the block.
	for (unsigned i = 0; i != outStr.length(); ++i) {
	if (outStr[i] == '\n') {
	outStr[i] = '\\';
	outStr.insert(outStr.begin() + i + 1, 'l');
	}
	}

	return outStr;
	}

	} // end namespace llvm

	void mlir::viewGraph(Region &region, const Twine &name, bool shortNames,
	const Twine &title, llvm::GraphProgram::Name program) {
	llvm::ViewGraph(&region, name, shortNames, title, program);
	}

	raw_ostream &mlir::writeGraph(raw_ostream &os, Region &region, bool shortNames,
	const Twine &title) {
	return llvm::WriteGraph(os, &region, shortNames, title);
	}

	void mlir::Region::viewGraph(const Twine &regionName) {
	::mlir::viewGraph(*this, regionName);
	}
	void mlir::Region::viewGraph() { viewGraph("region"); }

	namespace {
	struct PrintCFGPass : public PrintCFGBase<PrintCFGPass> {
	PrintCFGPass(raw_ostream &os = llvm::errs(), bool shortNames = false,
	const Twine &title = "")
	: os(os), shortNames(shortNames), title(title.str()) {}
	void runOnFunction() override {
	mlir::writeGraph(os, getFunction().getBody(), shortNames, title);
	}

	private:
	raw_ostream &os;
	bool shortNames;
	std::string title;
	};
	} // namespace

	std::unique_ptr<mlir::OperationPass<mlir::FuncOp>>
	mlir::createPrintCFGGraphPass(raw_ostream &os, bool shortNames,
	const Twine &title) {
	return std::make_unique<PrintCFGPass>(os, shortNames, title);
	}

mlir/test/Transforms/print-op-graph.mlir

	// RUN: mlir-opt -allow-unregistered-dialect -mlir-elide-elementsattrs-if-larger=2 -view-op-graph %s -o %t 2>&1 \| FileCheck %s			// RUN: mlir-opt -allow-unregistered-dialect -mlir-elide-elementsattrs-if-larger=2 -view-op-graph %s -o %t 2>&1 \| FileCheck -check-prefix=DFG %s
				// RUN: mlir-opt -allow-unregistered-dialect -mlir-elide-elementsattrs-if-larger=2 -view-op-graph='print-data-flow-edges=false print-control-flow-edges=true' %s -o %t 2>&1 \| FileCheck -check-prefix=CFG %s

				// DFG-LABEL: digraph G {
				// DFG: subgraph {{.*}} {
				// DFG: subgraph {{.*}}
				// DFG: label = "builtin.func{{.*}}merge_blocks
				// DFG: subgraph {{.*}} {
				// DFG: v[[ARG0:.*]] [label = "arg0"
				// DFG: v[[CONST10:.]] [label ={{.}}10 : i32
				// DFG: subgraph [[CLUSTER_MERGE_BLOCKS:.*]] {
				// DFG: v[[ANCHOR:.*]] [label = " ", shape = plain]
				// DFG: label = "test.merge_blocks
				// DFG: subgraph {{.*}} {
				// DFG: v[[TEST_BR:.*]] [label = "test.br
				// DFG: }
				// DFG: subgraph {{.*}} {
				// DFG: }
				// DFG: }
				// DFG: v[[TEST_RET:.*]] [label = "test.return
				// DFG: v[[ARG0]] -> v[[TEST_BR]]
				// DFG: v[[CONST10]] -> v[[TEST_BR]]
				// DFG: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]]
				// DFG: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]]

				// CFG-LABEL: digraph G {
				// CFG: subgraph {{.*}} {
				// CFG: subgraph {{.*}}
				// CFG: label = "builtin.func{{.*}}merge_blocks
				// CFG: subgraph {{.*}} {
				// CFG: v[[C1:.*]] [label = "std.constant
				// CFG: v[[C2:.*]] [label = "std.constant
				// CFG: v[[C3:.*]] [label = "std.constant
				// CFG: v[[C4:.*]] [label = "std.constant
				// CFG: v[[TEST_FUNC:.*]] [label = "test.func
				// CFG: subgraph [[CLUSTER_MERGE_BLOCKS:.*]] {
				// CFG: v[[ANCHOR:.*]] [label = " ", shape = plain]
				// CFG: label = "test.merge_blocks
				// CFG: subgraph {{.*}} {
				// CFG: v[[TEST_BR:.*]] [label = "test.br
				// CFG: }
				// CFG: subgraph {{.*}} {
				// CFG: }
				// CFG: }
				// CFG: v[[TEST_RET:.*]] [label = "test.return
				// CFG: v[[C1]] -> v[[C2]]
				// CFG: v[[C2]] -> v[[C3]]
				// CFG: v[[C3]] -> v[[C4]]
				// CFG: v[[C4]] -> v[[TEST_FUNC]]
				// CFG: v[[TEST_FUNC]] -> v[[ANCHOR]] [{{.*}}, lhead = [[CLUSTER_MERGE_BLOCKS]]]
				// CFG: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]]

	// CHECK-LABEL: digraph G {
	// CHECK: subgraph {{.*}} {
	// CHECK: subgraph {{.*}}
	// CHECK: label = "builtin.func{{.*}}merge_blocks
	// CHECK: subgraph {{.*}} {
	// CHECK: v[[ARG0:.*]] [label = "arg0"
	// CHECK: v[[CONST10:.]] [label ={{.}}10 : i32
	// CHECK: subgraph [[CLUSTER_MERGE_BLOCKS:.*]] {
	// CHECK: v[[ANCHOR:.*]] [label = " ", shape = plain]
	// CHECK: label = "test.merge_blocks
	// CHECK: subgraph {{.*}} {
	// CHECK: v[[TEST_BR:.*]] [label = "test.br
	// CHECK: }
	// CHECK: subgraph {{.*}} {
	// CHECK: }
	// CHECK: }
	// CHECK: v[[TEST_RET:.*]] [label = "test.return
	// CHECK: v[[ARG0]] -> v[[TEST_BR]]
	// CHECK: v[[CONST10]] -> v[[TEST_BR]]
	// CHECK: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]]
	// CHECK: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]]
	func @merge_blocks(%arg0: i32, %arg1 : i32) -> () {			func @merge_blocks(%arg0: i32, %arg1 : i32) -> () {
	%0 = constant dense<[[0, 1], [2, 3]]> : tensor<2x2xi32>			%0 = constant dense<[[0, 1], [2, 3]]> : tensor<2x2xi32>
	%1 = constant dense<1> : tensor<5xi32>			%1 = constant dense<1> : tensor<5xi32>
	%2 = constant dense<[[0, 1]]> : tensor<1x2xi32>			%2 = constant dense<[[0, 1]]> : tensor<1x2xi32>
	%a = constant 10 : i32			%a = constant 10 : i32
	%b = "test.func"() : () -> i32			%b = "test.func"() : () -> i32
	%3:2 = "test.merge_blocks"() ({			%3:2 = "test.merge_blocks"() ({
	^bb0:			^bb0:
	"test.br"(%arg0, %b, %a)[^bb1] : (i32, i32, i32) -> ()			"test.br"(%arg0, %b, %a)[^bb1] : (i32, i32, i32) -> ()
	^bb1(%arg3 : i32, %arg4 : i32, %arg5: i32):			^bb1(%arg3 : i32, %arg4 : i32, %arg5: i32):
	"test.return"(%arg3, %arg4) : (i32, i32) -> ()			"test.return"(%arg3, %arg4) : (i32, i32) -> ()
	}) : () -> (i32, i32)			}) : () -> (i32, i32)
	"test.return"(%3#0, %3#1) : (i32, i32) -> ()			"test.return"(%3#0, %3#1) : (i32, i32) -> ()
	}			}

This is an archive of the discontinued LLVM Phabricator instance.

[mlir] Support drawing control-flow graphs in ViewOpGraph.cppClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 364046

mlir/include/mlir/Transforms/Passes.h

mlir/include/mlir/Transforms/Passes.td

mlir/include/mlir/Transforms/ViewRegionGraph.h

mlir/lib/Transforms/CMakeLists.txt

mlir/lib/Transforms/NormalizeMemRefs.cpp

mlir/lib/Transforms/ViewOpGraph.cpp

mlir/lib/Transforms/ViewRegionGraph.cpp

mlir/test/Transforms/print-op-graph.mlir

[mlir] Support drawing control-flow graphs in ViewOpGraph.cpp
ClosedPublic