[mlir][transform] Handle multiple library preloading passes #69320
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This is a preparatory commit for fixing the handling of multiple transform library modules. The plan is to merge every newly loaded module into the global library module rather than keeping around a list. Since that merging happens in the dialect and depends on the dialect, the two depend on each other and thus have to live in the same CMake target.
The transform dialect stores a "library module" that the preload pass can populate. Until now, each pass registered an additional module by simply pushing it to a vector; however, the interpreter only used the first of them. This commit turns the registration into "loading", i.e., each newly added module gets merged into the existing one. This allows the loading to be split into several passes, and using the library in the interpreter now takes all of them into account. While this design avoids repeated merging every time the library is accessed, it requires that the implementation of merging modules lives in the `TransformDialect` target (since it at the dialect depend on each other). This resolves llvm#69111.
ingomueller-net
requested review from
ftynse,
matthias-springer and
nicolasvasilache
|
@llvm/pr-subscribers-mlir Author: Ingo Müller (ingomueller-net) ChangesThe transform dialect stores a "library module" that the preload pass This resolves #69111. Patch is 43.87 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/69320.diff 9 Files Affected:
diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h b/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
index db27f2c6fc49b75..b696438eb3532c4 100644
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
@@ -315,6 +315,62 @@ class BuildOnly : public DerivedTy {
BuildOnly() : DerivedTy(/*buildOnly=*/true) {}
};
+namespace detail {
+
+/// Expands the given list of `paths` to a list of `.mlir` files.
+///
+/// Each entry in `paths` may either be a regular file, in which case it ends up
+/// in the result list, or a directory, in which case all (regular) `.mlir`
+/// files in that directory are added. Any other file types lead to a failure.
+LogicalResult expandPathsToMLIRFiles(ArrayRef<std::string> &paths,
+ MLIRContext *context,
+ SmallVectorImpl<std::string> &fileNames);
+
+/// Utility to parse and verify the content of a `transformFileName` MLIR file
+/// containing a transform dialect specification.
+LogicalResult
+parseTransformModuleFromFile(MLIRContext *context,
+ llvm::StringRef transformFileName,
+ OwningOpRef<ModuleOp> &transformModule);
+
+/// Utility to parse, verify, aggregate and link the content of all mlir files
+/// nested under `transformLibraryPaths` and containing transform dialect
+/// specifications.
+LogicalResult
+assembleTransformLibraryFromPaths(MLIRContext *context,
+ ArrayRef<std::string> transformLibraryPaths,
+ OwningOpRef<ModuleOp> &transformModule);
+
+/// Utility to load a transform interpreter `module` from a module that has
+/// already been preloaded in the context.
+/// This mode is useful in cases where explicit parsing of a transform library
+/// from file is expected to be prohibitively expensive.
+/// In such cases, the transform module is expected to be found in the preloaded
+/// library modules of the transform dialect.
+/// Returns null if the module is not found.
+ModuleOp getPreloadedTransformModule(MLIRContext *context);
+
+/// Merge all symbols from `other` into `target`. Both ops need to implement the
+/// `SymbolTable` trait. Operations are moved from `other`, i.e., `other` may be
+/// modified by this function and might not verify after the function returns.
+/// Upon merging, private symbols may be renamed in order to avoid collisions in
+/// the result. Public symbols may not collide, with the exception of
+/// instances of `SymbolOpInterface`, where collisions are allowed if at least
+/// one of the two is external, in which case the other op preserved (or any one
+/// of the two if both are external).
+// TODO: Reconsider cloning individual ops rather than forcing users of the
+// function to clone (or move) `other` in order to improve efficiency.
+// This might primarily make sense if we can also prune the symbols that
+// are merged to a subset (such as those that are actually used).
+LogicalResult mergeSymbolsInto(Operation *target,
+ OwningOpRef<Operation *> other);
+
+/// Merge all symbols from `others` into `target`. See overload of
+/// `mergeSymbolsInto` on one `other` op for details.
+LogicalResult
+mergeSymbolsInto(Operation *target,
+ MutableArrayRef<OwningOpRef<Operation *>> others);
+} // namespace detail
} // namespace transform
} // namespace mlir
diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.td b/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.td
index ad6804673b770ca..211663258bfb133 100644
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.td
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.td
@@ -78,20 +78,19 @@ def Transform_Dialect : Dialect {
using ExtensionTypePrintingHook =
std::function<void(::mlir::Type, ::mlir::AsmPrinter &)>;
- /// Appends the given module as a transform symbol library available to
- /// all dialect users.
- void registerLibraryModule(::mlir::OwningOpRef<::mlir::ModuleOp> &&
- library) {
- libraryModules.push_back(std::move(library));
- }
-
- /// Returns a range of registered library modules.
- auto getLibraryModules() const {
- return ::llvm::map_range(
- libraryModules,
- [](const ::mlir::OwningOpRef<::mlir::ModuleOp> &library) {
- return library.get();
- });
+ /// Loads the given module into the transform symbol library module.
+ void initializeLibraryModule();
+
+ /// Loads the given module into the transform symbol library module.
+ LogicalResult loadIntoLibraryModule(::mlir::OwningOpRef<::mlir::ModuleOp> &&
+ library);
+
+ /// Returns the transform symbol library module available to all dialect
+ /// users.
+ ModuleOp getLibraryModule() const {
+ if (libraryModule)
+ return libraryModule.get();
+ return ModuleOp();
}
private:
@@ -153,10 +152,9 @@ def Transform_Dialect : Dialect {
::llvm::DenseMap<::mlir::TypeID, ExtensionTypePrintingHook>
typePrintingHooks;
- /// Modules containing symbols, e.g. named sequences, that will be
- /// resolved by the interpreter when used.
- ::llvm::SmallVector<::mlir::OwningOpRef<::mlir::ModuleOp>, 2>
- libraryModules;
+ /// Module containing symbols, e.g. named sequences, that will be resolved
+ /// by the interpreter when used.
+ ::mlir::OwningOpRef<::mlir::ModuleOp> libraryModule;
}];
}
diff --git a/mlir/include/mlir/Dialect/Transform/Transforms/TransformInterpreterUtils.h b/mlir/include/mlir/Dialect/Transform/Transforms/TransformInterpreterUtils.h
index 3fc02267f26e9da..6ca6b8aa5e79e17 100644
--- a/mlir/include/mlir/Dialect/Transform/Transforms/TransformInterpreterUtils.h
+++ b/mlir/include/mlir/Dialect/Transform/Transforms/TransformInterpreterUtils.h
@@ -26,40 +26,6 @@ class Region;
namespace transform {
namespace detail {
-
-/// Expands the given list of `paths` to a list of `.mlir` files.
-///
-/// Each entry in `paths` may either be a regular file, in which case it ends up
-/// in the result list, or a directory, in which case all (regular) `.mlir`
-/// files in that directory are added. Any other file types lead to a failure.
-LogicalResult expandPathsToMLIRFiles(ArrayRef<std::string> &paths,
- MLIRContext *context,
- SmallVectorImpl<std::string> &fileNames);
-
-/// Utility to parse and verify the content of a `transformFileName` MLIR file
-/// containing a transform dialect specification.
-LogicalResult
-parseTransformModuleFromFile(MLIRContext *context,
- llvm::StringRef transformFileName,
- OwningOpRef<ModuleOp> &transformModule);
-
-/// Utility to parse, verify, aggregate and link the content of all mlir files
-/// nested under `transformLibraryPaths` and containing transform dialect
-/// specifications.
-LogicalResult
-assembleTransformLibraryFromPaths(MLIRContext *context,
- ArrayRef<std::string> transformLibraryPaths,
- OwningOpRef<ModuleOp> &transformModule);
-
-/// Utility to load a transform interpreter `module` from a module that has
-/// already been preloaded in the context.
-/// This mode is useful in cases where explicit parsing of a transform library
-/// from file is expected to be prohibitively expensive.
-/// In such cases, the transform module is expected to be found in the preloaded
-/// library modules of the transform dialect.
-/// Returns null if the module is not found.
-ModuleOp getPreloadedTransformModule(MLIRContext *context);
-
/// Finds the first TransformOpInterface named `kTransformEntryPointSymbolName`
/// that is either:
/// 1. nested under `root` (takes precedence).
@@ -68,21 +34,6 @@ ModuleOp getPreloadedTransformModule(MLIRContext *context);
TransformOpInterface findTransformEntryPoint(
Operation *root, ModuleOp module,
StringRef entryPoint = TransformDialect::kTransformEntryPointSymbolName);
-
-/// Merge all symbols from `other` into `target`. Both ops need to implement the
-/// `SymbolTable` trait. Operations are moved from `other`, i.e., `other` may be
-/// modified by this function and might not verify after the function returns.
-/// Upon merging, private symbols may be renamed in order to avoid collisions in
-/// the result. Public symbols may not collide, with the exception of
-/// instances of `SymbolOpInterface`, where collisions are allowed if at least
-/// one of the two is external, in which case the other op preserved (or any one
-/// of the two if both are external).
-// TODO: Reconsider cloning individual ops rather than forcing users of the
-// function to clone (or move) `other` in order to improve efficiency.
-// This might primarily make sense if we can also prune the symbols that
-// are merged to a subset (such as those that are actually used).
-LogicalResult mergeSymbolsInto(Operation *target,
- OwningOpRef<Operation *> other);
} // namespace detail
/// Standalone util to apply the named sequence `entryPoint` to the payload.
diff --git a/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp b/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
index 32c56e903268f74..e12176be57b0eb7 100644
--- a/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
+++ b/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
@@ -12,7 +12,15 @@
#include "mlir/Dialect/Transform/IR/TransformOps.h"
#include "mlir/Dialect/Transform/IR/TransformTypes.h"
#include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/Verifier.h"
+#include "mlir/Parser/Parser.h"
+#include "mlir/Support/FileUtilities.h"
#include "llvm/ADT/SCCIterator.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/SourceMgr.h"
+
+#define DEBUG_TYPE "transform-dialect"
+#define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE << "]: ")
using namespace mlir;
@@ -65,6 +73,7 @@ void transform::TransformDialect::initialize() {
#include "mlir/Dialect/Transform/IR/TransformOps.cpp.inc"
>();
initializeTypes();
+ initializeLibraryModule();
}
Type transform::TransformDialect::parseType(DialectAsmParser &parser) const {
@@ -89,6 +98,20 @@ void transform::TransformDialect::printType(Type type,
it->getSecond()(type, printer);
}
+void transform::TransformDialect::initializeLibraryModule() {
+ MLIRContext *context = getContext();
+ auto loc =
+ FileLineColLoc::get(context, "<transform-dialect-library-module>", 0, 0);
+ libraryModule = ModuleOp::create(loc, "__transform_library");
+ libraryModule.get()->setAttr(TransformDialect::kWithNamedSequenceAttrName,
+ UnitAttr::get(context));
+}
+
+LogicalResult transform::TransformDialect::loadIntoLibraryModule(
+ ::mlir::OwningOpRef<::mlir::ModuleOp> &&library) {
+ return detail::mergeSymbolsInto(getLibraryModule(), std::move(library));
+}
+
void transform::TransformDialect::reportDuplicateTypeRegistration(
StringRef mnemonic) {
std::string buffer;
@@ -172,3 +195,357 @@ LogicalResult transform::TransformDialect::verifyOperationAttribute(
return emitError(op->getLoc())
<< "unknown attribute: " << attribute.getName();
}
+
+/// Expands the given list of `paths` to a list of `.mlir` files.
+///
+/// Each entry in `paths` may either be a regular file, in which case it ends up
+/// in the result list, or a directory, in which case all (regular) `.mlir`
+/// files in that directory are added. Any other file types lead to a failure.
+LogicalResult transform::detail::expandPathsToMLIRFiles(
+ ArrayRef<std::string> &paths, MLIRContext *context,
+ SmallVectorImpl<std::string> &fileNames) {
+ for (const std::string &path : paths) {
+ auto loc = FileLineColLoc::get(context, path, 0, 0);
+
+ if (llvm::sys::fs::is_regular_file(path)) {
+ LLVM_DEBUG(DBGS() << "Adding '" << path << "' to list of files\n");
+ fileNames.push_back(path);
+ continue;
+ }
+
+ if (!llvm::sys::fs::is_directory(path)) {
+ return emitError(loc)
+ << "'" << path << "' is neither a file nor a directory";
+ }
+
+ LLVM_DEBUG(DBGS() << "Looking for files in '" << path << "':\n");
+
+ std::error_code ec;
+ for (llvm::sys::fs::directory_iterator it(path, ec), itEnd;
+ it != itEnd && !ec; it.increment(ec)) {
+ const std::string &fileName = it->path();
+
+ if (it->type() != llvm::sys::fs::file_type::regular_file) {
+ LLVM_DEBUG(DBGS() << " Skipping non-regular file '" << fileName
+ << "'\n");
+ continue;
+ }
+
+ if (!StringRef(fileName).endswith(".mlir")) {
+ LLVM_DEBUG(DBGS() << " Skipping '" << fileName
+ << "' because it does not end with '.mlir'\n");
+ continue;
+ }
+
+ LLVM_DEBUG(DBGS() << " Adding '" << fileName << "' to list of files\n");
+ fileNames.push_back(fileName);
+ }
+
+ if (ec)
+ return emitError(loc) << "error while opening files in '" << path
+ << "': " << ec.message();
+ }
+
+ return success();
+}
+
+LogicalResult transform::detail::parseTransformModuleFromFile(
+ MLIRContext *context, llvm::StringRef transformFileName,
+ OwningOpRef<ModuleOp> &transformModule) {
+ if (transformFileName.empty()) {
+ LLVM_DEBUG(
+ DBGS() << "no transform file name specified, assuming the transform "
+ "module is embedded in the IR next to the top-level\n");
+ return success();
+ }
+ // Parse transformFileName content into a ModuleOp.
+ std::string errorMessage;
+ auto memoryBuffer = mlir::openInputFile(transformFileName, &errorMessage);
+ if (!memoryBuffer) {
+ return emitError(FileLineColLoc::get(
+ StringAttr::get(context, transformFileName), 0, 0))
+ << "failed to open transform file: " << errorMessage;
+ }
+ // Tell sourceMgr about this buffer, the parser will pick it up.
+ llvm::SourceMgr sourceMgr;
+ sourceMgr.AddNewSourceBuffer(std::move(memoryBuffer), llvm::SMLoc());
+ transformModule =
+ OwningOpRef<ModuleOp>(parseSourceFile<ModuleOp>(sourceMgr, context));
+ return mlir::verify(*transformModule);
+}
+
+ModuleOp transform::detail::getPreloadedTransformModule(MLIRContext *context) {
+ return context->getOrLoadDialect<transform::TransformDialect>()
+ ->getLibraryModule();
+}
+
+LogicalResult transform::detail::assembleTransformLibraryFromPaths(
+ MLIRContext *context, ArrayRef<std::string> transformLibraryPaths,
+ OwningOpRef<ModuleOp> &transformModule) {
+ // Assemble list of library files.
+ SmallVector<std::string> libraryFileNames;
+ if (failed(detail::expandPathsToMLIRFiles(transformLibraryPaths, context,
+ libraryFileNames)))
+ return failure();
+
+ // Parse modules from library files.
+ SmallVector<OwningOpRef<ModuleOp>> parsedLibraries;
+ for (const std::string &libraryFileName : libraryFileNames) {
+ OwningOpRef<ModuleOp> parsedLibrary;
+ if (failed(transform::detail::parseTransformModuleFromFile(
+ context, libraryFileName, parsedLibrary)))
+ return failure();
+ parsedLibraries.push_back(std::move(parsedLibrary));
+ }
+
+ // Merge parsed libraries into one module.
+ auto loc = FileLineColLoc::get(context, "<shared-library-module>", 0, 0);
+ OwningOpRef<ModuleOp> mergedParsedLibraries =
+ ModuleOp::create(loc, "__transform");
+ {
+ mergedParsedLibraries.get()->setAttr("transform.with_named_sequence",
+ UnitAttr::get(context));
+ IRRewriter rewriter(context);
+ // TODO: extend `mergeSymbolsInto` to support multiple `other` modules.
+ for (OwningOpRef<ModuleOp> &parsedLibrary : parsedLibraries) {
+ if (failed(transform::detail::mergeSymbolsInto(
+ mergedParsedLibraries.get(), std::move(parsedLibrary))))
+ return mergedParsedLibraries->emitError()
+ << "failed to verify merged transform module";
+ }
+ }
+
+ transformModule = std::move(mergedParsedLibraries);
+ return success();
+}
+
+/// Return whether `func1` can be merged into `func2`. For that to work
+/// `func1` has to be a declaration (aka has to be external) and `func2`
+/// either has to be a declaration as well, or it has to be public (otherwise,
+/// it wouldn't be visible by `func1`).
+static bool canMergeInto(FunctionOpInterface func1, FunctionOpInterface func2) {
+ return func1.isExternal() && (func2.isPublic() || func2.isExternal());
+}
+
+/// Merge `func1` into `func2`. The two ops must be inside the same parent op
+/// and mergable according to `canMergeInto`. The function erases `func1` such
+/// that only `func2` exists when the function returns.
+static LogicalResult mergeInto(FunctionOpInterface func1,
+ FunctionOpInterface func2) {
+ assert(canMergeInto(func1, func2));
+ assert(func1->getParentOp() == func2->getParentOp() &&
+ "expected func1 and func2 to be in the same parent op");
+
+ // Check that function signatures match.
+ if (func1.getFunctionType() != func2.getFunctionType()) {
+ return func1.emitError()
+ << "external definition has a mismatching signature ("
+ << func2.getFunctionType() << ")";
+ }
+
+ // Check and merge argument attributes.
+ MLIRContext *context = func1->getContext();
+ auto *td = context->getLoadedDialect<transform::TransformDialect>();
+ StringAttr consumedName = td->getConsumedAttrName();
+ StringAttr readOnlyName = td->getReadOnlyAttrName();
+ for (unsigned i = 0, e = func1.getNumArguments(); i < e; ++i) {
+ bool isExternalConsumed = func2.getArgAttr(i, consumedName) != nullptr;
+ bool isExternalReadonly = func2.getArgAttr(i, readOnlyName) != nullptr;
+ bool isConsumed = func1.getArgAttr(i, consumedName) != nullptr;
+ bool isReadonly = func1.getArgAttr(i, readOnlyName) != nullptr;
+ if (!isExternalConsumed && !isExternalReadonly) {
+ if (isConsumed)
+ func2.setArgAttr(i, consumedName, UnitAttr::get(context));
+ else if (isReadonly)
+ func2.setArgAttr(i, readOnlyName, UnitAttr::get(context));
+ continue;
+ }
+
+ if ((isExternalConsumed && !isConsumed) ||
+ (isExternalReadonly && !isReadonly)) {
+ return func1.emitError()
+ << "external definition has mismatching consumption "
+ "annotations for argument #"
+ << i;
+ }
+ }
+
+ // `func1` is the external one, so we can remove it.
+ assert(func1.isExternal());
+ func1->erase();
+
+ return success();
+}
+
+LogicalResult
+transform::detail::mergeSymbolsInto(Operation *target,
+ OwningOpRef<Operation *> other) {
+ assert(target->hasTrait<OpTrait::SymbolTable>() &&
+ "requires target to implement the 'SymbolTable' trait");
+ assert(other->hasTrait<OpTrait::SymbolTable>() &&
+ "requires target to implement the 'SymbolTable' trait");
+
+ SymbolTable targetSymbolTable(target);
+ SymbolTable otherSymbolTable(*other);
+
+ // Step 1:
+ //
+ // Rename private symbols in both ops in order to resolve conflicts that can
+ // be resolved that way.
+ LLVM_DEBUG(DBGS() << "renaming private symbols to resolve conflicts:\n");
+ // TODO: Do we *actually* need to test in both directions?
+ for (auto &&[symbolTable, otherSymbolTable] : llvm::zip(
+ SmallVector<SymbolTable *, 2>{&targetSymbolTable, &otherSymbolTable},
+ SmallVector<SymbolTable *, 2>{&otherSymbolTable,
+ &targetSymbolTable})) {
+ Operation *symbolTableOp = symbolTable->getOp();
+ for (Operation &op : symbolTableOp->getRegion(0).front()) {
+ auto symbolOp = dyn_cast<SymbolOpInterface>(op);
+ if (!symbolOp)
+ continue;
+ StringAttr name = symbolOp.getNameAttr();
+ LLVM_DEBUG(DBGS() << " found @" << name.getValue() << "\n");
+
+ // Check if there is a colliding op in the other module.
+ auto collidingOp =
+ cast_or_null<SymbolOpInterface>(otherSymbolTable->lookup(name));
+ if (!collidingOp)
+ continue;
+
+ ...
[truncated]
|
ftynse
requested changes
Oct 17, 2023
| @@ -315,6 +315,62 @@ class BuildOnly : public DerivedTy { | |||
| BuildOnly() : DerivedTy(/*buildOnly=*/true) {} | |||
| }; | |||
|
|
|||
| namespace detail { | |||
There was a problem hiding this comment.
Can this go to some new Utils header? This doesn't look like stuff that belongs to the dialect definition.
There was a problem hiding this comment.
Yep, makes sense. I realized that I only have to move the mergeSymbolsInto function (and related static functions). The remaining ones (for expanding paths etc) are arguably more related to the interpreter pass than this one, so I am leaving them where they are.
For now, I am calling the files Utils.h/Utils.cpp. All other files are called TransformSomething.xxx -- should I rename the new files to TransformUtils.xxx as well to follow that scheme?
| /// Each entry in `paths` may either be a regular file, in which case it ends up | ||
| /// in the result list, or a directory, in which case all (regular) `.mlir` | ||
| /// files in that directory are added. Any other file types lead to a failure. | ||
| LogicalResult expandPathsToMLIRFiles(ArrayRef<std::string> &paths, |
There was a problem hiding this comment.
Why take a reference to ArrayRef, which itself is a reference as the name indicates?
(I see the code is moved from elsewhere, but IIRC it's yours anyway).
There was a problem hiding this comment.
No good reason. I probably changed the type from something else and overlooked the & when I changed it to ArrayRef. Fixed in new PR.
Comment on lines
+256
to
+258
| LLVM_DEBUG( | ||
| DBGS() << "no transform file name specified, assuming the transform " | ||
| "module is embedded in the IR next to the top-level\n"); |
There was a problem hiding this comment.
This message no longer corresponds to the usages of this function and is only confusing. Furthermore, I'm not convinced that returning success here is the right behavior for this function in the more general case. Nothing was parsed.
There was a problem hiding this comment.
True, good catch. I removed that whole check in the new PR.
| [](const ::mlir::OwningOpRef<::mlir::ModuleOp> &library) { | ||
| return library.get(); | ||
| }); | ||
| /// Loads the given module into the transform symbol library module. |
There was a problem hiding this comment.
Documentation looks copy-pasted from below.
| { | ||
| mergedParsedLibraries.get()->setAttr("transform.with_named_sequence", | ||
| UnitAttr::get(context)); | ||
| IRRewriter rewriter(context); |
There was a problem hiding this comment.
Haha, no idea. Removed.
| Operation *target, MutableArrayRef<OwningOpRef<Operation *>> others) { | ||
| for (OwningOpRef<Operation *> &other : others) { | ||
| if (failed(transform::detail::mergeSymbolsInto(target, std::move(other)))) | ||
| return target->emitError() << "failed to verify merged transform module"; |
There was a problem hiding this comment.
The callee has already reported an error, we shouldn't need to emit another error. It is also not necessarily a failure to verify.
ingomueller-net
commented
Oct 20, 2023
There was a problem hiding this comment.
Thanks a lot for the review! I have addressed all raised issues here: #69705. I started a new PR because the code that I had to move has changed in main in the meantime, and I had to move it again (plus I decided to move fewer things). I'll abandon this PR in favor of the new one now.
| @@ -315,6 +315,62 @@ class BuildOnly : public DerivedTy { | |||
| BuildOnly() : DerivedTy(/*buildOnly=*/true) {} | |||
| }; | |||
|
|
|||
| namespace detail { | |||
There was a problem hiding this comment.
Yep, makes sense. I realized that I only have to move the mergeSymbolsInto function (and related static functions). The remaining ones (for expanding paths etc) are arguably more related to the interpreter pass than this one, so I am leaving them where they are.
For now, I am calling the files Utils.h/Utils.cpp. All other files are called TransformSomething.xxx -- should I rename the new files to TransformUtils.xxx as well to follow that scheme?
| /// Each entry in `paths` may either be a regular file, in which case it ends up | ||
| /// in the result list, or a directory, in which case all (regular) `.mlir` | ||
| /// files in that directory are added. Any other file types lead to a failure. | ||
| LogicalResult expandPathsToMLIRFiles(ArrayRef<std::string> &paths, |
There was a problem hiding this comment.
No good reason. I probably changed the type from something else and overlooked the & when I changed it to ArrayRef. Fixed in new PR.
Comment on lines
+256
to
+258
| LLVM_DEBUG( | ||
| DBGS() << "no transform file name specified, assuming the transform " | ||
| "module is embedded in the IR next to the top-level\n"); |
There was a problem hiding this comment.
True, good catch. I removed that whole check in the new PR.
| { | ||
| mergedParsedLibraries.get()->setAttr("transform.with_named_sequence", | ||
| UnitAttr::get(context)); | ||
| IRRewriter rewriter(context); |
There was a problem hiding this comment.
Haha, no idea. Removed.
| Operation *target, MutableArrayRef<OwningOpRef<Operation *>> others) { | ||
| for (OwningOpRef<Operation *> &other : others) { | ||
| if (failed(transform::detail::mergeSymbolsInto(target, std::move(other)))) | ||
| return target->emitError() << "failed to verify merged transform module"; |
|
Closing in favor of new attempt in #69705. |
ingomueller-net
added a commit
that referenced
this pull request
Oct 25, 2023
This is a new attempt at #69320. The transform dialect stores a "library module" that the preload pass can populate. Until now, each pass registered an additional module by simply pushing it to a vector; however, the interpreter only used the first of them. This commit turns the registration into "loading", i.e., each newly added module gets merged into the existing one. This allows the loading to be split into several passes, and using the library in the interpreter now takes all of them into account. While this design avoids repeated merging every time the library is accessed, it requires that the implementation of merging modules lives in the TransformDialect target (since it at the dialect depend on each other). This resolves #69111.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
The transform dialect stores a "library module" that the preload pass
can populate. Until now, each pass registered an additional module by
simply pushing it to a vector; however, the interpreter only used the
first of them. This commit turns the registration into "loading", i.e.,
each newly added module gets merged into the existing one. This allows
the loading to be split into several passes, and using the library in
the interpreter now takes all of them into account. While this design
avoids repeated merging every time the library is accessed, it requires
that the implementation of merging modules lives in the
TransformDialecttarget (since it at the dialect depend on eachother).
This resolves #69111.