Updating HAL passes to use tablegen. (#15952)
No functional changes, just boilerplate churn from C++ to tablegen and
other cleanup.
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Target/TargetRegistry.cpp b/compiler/src/iree/compiler/Dialect/HAL/Target/TargetRegistry.cpp
index 4860b91..2bac06c 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Target/TargetRegistry.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Target/TargetRegistry.cpp
@@ -130,3 +130,34 @@
}
} // namespace mlir::iree_compiler::IREE::HAL
+
+namespace llvm::cl {
+template class basic_parser<TargetBackendRegistryRef>;
+} // namespace llvm::cl
+
+using TargetBackendRegistryRef = llvm::cl::TargetBackendRegistryRef;
+
+// Return true on error.
+bool llvm::cl::parser<TargetBackendRegistryRef>::parse(
+ Option &O, StringRef ArgName, StringRef Arg,
+ TargetBackendRegistryRef &Val) {
+ // We ignore Arg here and just use the global registry. We could parse a list
+ // of target backends and create a new registry with just that subset but
+ // ownership gets tricky.
+ if (Arg != "global")
+ return true;
+ Val.value =
+ &mlir::iree_compiler::IREE::HAL::TargetBackendRegistry::getGlobal();
+ return false;
+}
+
+void llvm::cl::parser<TargetBackendRegistryRef>::printOptionDiff(
+ const Option &O, TargetBackendRegistryRef V, const OptVal &Default,
+ size_t GlobalWidth) const {
+ printOptionName(O, GlobalWidth);
+ std::string Str = "global";
+ outs() << "= " << Str;
+ outs().indent(2) << " (default: global)\n";
+}
+
+void llvm::cl::parser<TargetBackendRegistryRef>::anchor() {}
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Target/TargetRegistry.h b/compiler/src/iree/compiler/Dialect/HAL/Target/TargetRegistry.h
index 6927c13..07f933d 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Target/TargetRegistry.h
+++ b/compiler/src/iree/compiler/Dialect/HAL/Target/TargetRegistry.h
@@ -15,6 +15,7 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/CommandLine.h"
namespace mlir::iree_compiler::IREE::HAL {
@@ -96,4 +97,44 @@
} // namespace mlir::iree_compiler::IREE::HAL
+namespace llvm::cl {
+
+struct TargetBackendRegistryRef {
+ const mlir::iree_compiler::IREE::HAL::TargetBackendRegistry *value =
+ &mlir::iree_compiler::IREE::HAL::TargetBackendRegistry::getGlobal();
+ TargetBackendRegistryRef() = default;
+ TargetBackendRegistryRef(
+ const mlir::iree_compiler::IREE::HAL::TargetBackendRegistry &value)
+ : value(&value) {}
+ TargetBackendRegistryRef(
+ const mlir::iree_compiler::IREE::HAL::TargetBackendRegistry *value)
+ : value(value) {}
+ operator bool() const noexcept {
+ return value->getRegisteredTargetBackends() !=
+ mlir::iree_compiler::IREE::HAL::TargetBackendRegistry::getGlobal()
+ .getRegisteredTargetBackends();
+ }
+ const mlir::iree_compiler::IREE::HAL::TargetBackendRegistry *
+ operator->() const {
+ return value;
+ }
+};
+
+extern template class basic_parser<TargetBackendRegistryRef>;
+
+template <>
+class parser<TargetBackendRegistryRef>
+ : public basic_parser<TargetBackendRegistryRef> {
+public:
+ parser(Option &O) : basic_parser(O) {}
+ bool parse(Option &O, StringRef ArgName, StringRef Arg,
+ TargetBackendRegistryRef &Val);
+ StringRef getValueName() const override { return "target backend registry"; }
+ void printOptionDiff(const Option &O, TargetBackendRegistryRef V,
+ const OptVal &Default, size_t GlobalWidth) const;
+ void anchor() override;
+};
+
+} // namespace llvm::cl
+
#endif // IREE_COMPILER_DIALECT_HAL_TARGET_TARGETREGISTRY_H_
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/AssignTargetDevices.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/AssignTargetDevices.cpp
index 4ff28f6..e108e0b 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/AssignTargetDevices.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/AssignTargetDevices.cpp
@@ -23,36 +23,28 @@
namespace mlir::iree_compiler::IREE::HAL {
-class AssignTargetDevicesPass
- : public PassWrapper<AssignTargetDevicesPass, OperationPass<ModuleOp>> {
-public:
- AssignTargetDevicesPass()
- : targetRegistry(TargetBackendRegistry::getGlobal()) {}
- AssignTargetDevicesPass(const AssignTargetDevicesPass &pass)
- : targetRegistry(pass.targetRegistry) {}
- AssignTargetDevicesPass(const TargetBackendRegistry &targetRegistry,
- ArrayRef<std::string> targets)
- : targetRegistry(targetRegistry) {
- this->targets = targets;
- }
+#define GEN_PASS_DEF_ASSIGNTARGETDEVICESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+namespace {
+
+//===----------------------------------------------------------------------===//
+// --iree-hal-assign-target-devices
+//===----------------------------------------------------------------------===//
+
+struct AssignTargetDevicesPass
+ : public IREE::HAL::impl::AssignTargetDevicesPassBase<
+ AssignTargetDevicesPass> {
+ using IREE::HAL::impl::AssignTargetDevicesPassBase<
+ AssignTargetDevicesPass>::AssignTargetDevicesPassBase;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<IREE::HAL::HALDialect>();
- for (auto &targetBackend : targetRegistry.getTargetBackends(
- targetRegistry.getRegisteredTargetBackends())) {
+ for (auto &targetBackend : targetRegistry->getTargetBackends(
+ targetRegistry->getRegisteredTargetBackends())) {
targetBackend->getDependentDialects(registry);
}
}
- StringRef getArgument() const override {
- return "iree-hal-assign-target-devices";
- }
-
- StringRef getDescription() const override {
- return "Assigns the HAL devices the module will target to the given list "
- "of targets.";
- }
-
void runOnOperation() override {
auto moduleOp = getOperation();
@@ -76,13 +68,13 @@
llvm::SmallDenseSet<Attribute> targetAttrSet;
SmallVector<Attribute> targetAttrs;
for (const auto &targetName : targets) {
- auto targetBackend = targetRegistry.getTargetBackend(targetName);
+ auto targetBackend = targetRegistry->getTargetBackend(targetName);
if (!targetBackend) {
std::string backends;
llvm::raw_string_ostream os(backends);
llvm::interleaveComma(
- targetRegistry.getTargetBackends(
- targetRegistry.getRegisteredTargetBackends()),
+ targetRegistry->getTargetBackends(
+ targetRegistry->getRegisteredTargetBackends()),
os,
[&os](const std::shared_ptr<
mlir::iree_compiler::IREE::HAL::TargetBackend>
@@ -106,23 +98,8 @@
moduleOp->setAttr("hal.device.targets",
ArrayAttr::get(moduleOp.getContext(), targetAttrs));
}
-
-private:
- ListOption<std::string> targets{*this, "targets",
- llvm::cl::desc("List of devices to target."),
- llvm::cl::ZeroOrMore};
-
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<ModuleOp>>
-createAssignTargetDevicesPass(const TargetBackendRegistry &targetRegistry,
- ArrayRef<std::string> targets) {
- return std::make_unique<AssignTargetDevicesPass>(targetRegistry, targets);
-}
-
-static PassRegistration<AssignTargetDevicesPass> pass([] {
- return std::make_unique<AssignTargetDevicesPass>();
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/BUILD.bazel b/compiler/src/iree/compiler/Dialect/HAL/Transforms/BUILD.bazel
index 174c42f..a1d4f13 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/BUILD.bazel
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/BUILD.bazel
@@ -4,7 +4,7 @@
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-load("//build_tools/bazel:build_defs.oss.bzl", "iree_compiler_cc_library")
+load("//build_tools/bazel:build_defs.oss.bzl", "iree_compiler_cc_library", "iree_gentbl_cc_library")
package(
default_visibility = ["//visibility:public"],
@@ -16,7 +16,6 @@
name = "Transforms",
srcs = [
"AssignTargetDevices.cpp",
- "BenchmarkBatchDispatches.cpp",
"ConfigureExecutables.cpp",
"ConvertToHAL.cpp",
"DumpExecutableBenchmarks.cpp",
@@ -29,7 +28,9 @@
"MaterializeResourceCaches.cpp",
"MemoizeDeviceQueries.cpp",
"Passes.cpp",
+ "Passes.h.inc",
"PreprocessExecutables.cpp",
+ "RepeatDispatches.cpp",
"ResolveExportOrdinals.cpp",
"SerializeExecutables.cpp",
"StripExecutableContents.cpp",
@@ -41,6 +42,7 @@
"Passes.h",
],
deps = [
+ ":PassesIncGen",
"//compiler/src/iree/compiler/Codegen/Common/CPU:CommonCPUPasses",
"//compiler/src/iree/compiler/Codegen/Dialect:IREECodegenDialect",
"//compiler/src/iree/compiler/Dialect/Flow/IR",
@@ -78,3 +80,18 @@
"@llvm-project//mlir:Transforms",
],
)
+
+iree_gentbl_cc_library(
+ name = "PassesIncGen",
+ tbl_outs = [
+ (
+ ["--gen-pass-decls"],
+ "Passes.h.inc",
+ ),
+ ],
+ tblgen = "@llvm-project//mlir:mlir-tblgen",
+ td_file = "Passes.td",
+ deps = [
+ "@llvm-project//mlir:PassBaseTdFiles",
+ ],
+)
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/BenchmarkBatchDispatches.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/BenchmarkBatchDispatches.cpp
deleted file mode 100644
index 098f5dc..0000000
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/BenchmarkBatchDispatches.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2021 The IREE Authors
-//
-// Licensed 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 "iree/compiler/Dialect/HAL/IR/HALDialect.h"
-#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
-#include "iree/compiler/Dialect/HAL/IR/HALTypes.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir::iree_compiler::IREE::HAL {
-namespace {
-
-// Repeats dispatches a specified number of times.
-class BenchmarkBatchDispatchesPass
- : public PassWrapper<BenchmarkBatchDispatchesPass,
- OperationPass<func::FuncOp>> {
-public:
- MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(BenchmarkBatchDispatchesPass)
-
- explicit BenchmarkBatchDispatchesPass(unsigned repeatCount)
- : repeatCount_(repeatCount) {}
-
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<func::FuncDialect, IREE::HAL::HALDialect>();
- }
-
- StringRef getArgument() const override {
- return "test-iree-hal-benchmark-batch-dispatches-2-times";
- }
-
- StringRef getDescription() const override {
- return "Test pass used for benchmarking batch dispatches analysis";
- }
-
- void runOnOperation() override {
- // Collect all (nested) command buffer dispatch ops.
- std::vector<IREE::HAL::CommandBufferDispatchOp> ops;
- getOperation().walk(
- [&ops](IREE::HAL::CommandBufferDispatchOp op) { ops.push_back(op); });
- for (auto op : ops) {
- OpBuilder builder(op);
- for (unsigned i = 1; i < repeatCount_; ++i) {
- builder.clone(*op.getOperation());
- // Add a barrier after each clone. If the original dispatch has a small
- // problem size, simply duplicating without barrier will increase the
- // number of subgroups and thus "help" filling the GPU. In the end we
- // will have an over optimistic result. Inserting barriers avoids that,
- // but it assumes that the command buffer has a linear dispatch
- // structure.
- builder.create<IREE::HAL::CommandBufferExecutionBarrierOp>(
- op.getLoc(), op.getCommandBuffer(),
- IREE::HAL::ExecutionStageBitfield::CommandRetire |
- IREE::HAL::ExecutionStageBitfield::Dispatch,
- IREE::HAL::ExecutionStageBitfield::CommandIssue |
- IREE::HAL::ExecutionStageBitfield::Dispatch,
- IREE::HAL::ExecutionBarrierFlagBitfield::None);
- }
- }
- }
-
-private:
- unsigned repeatCount_;
-};
-
-} // namespace
-
-std::unique_ptr<OperationPass<func::FuncOp>>
-createBenchmarkBatchDispatchesPass(unsigned repeatCount) {
- return std::make_unique<BenchmarkBatchDispatchesPass>(repeatCount);
-}
-
-static PassRegistration<BenchmarkBatchDispatchesPass> pass([] {
- return std::make_unique<BenchmarkBatchDispatchesPass>(2);
-});
-
-} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/CMakeLists.txt b/compiler/src/iree/compiler/Dialect/HAL/Transforms/CMakeLists.txt
index b24af6a..d88c4fb 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/CMakeLists.txt
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/CMakeLists.txt
@@ -17,7 +17,6 @@
"Passes.h"
SRCS
"AssignTargetDevices.cpp"
- "BenchmarkBatchDispatches.cpp"
"ConfigureExecutables.cpp"
"ConvertToHAL.cpp"
"DumpExecutableBenchmarks.cpp"
@@ -30,7 +29,9 @@
"MaterializeResourceCaches.cpp"
"MemoizeDeviceQueries.cpp"
"Passes.cpp"
+ "Passes.h.inc"
"PreprocessExecutables.cpp"
+ "RepeatDispatches.cpp"
"ResolveExportOrdinals.cpp"
"SerializeExecutables.cpp"
"StripExecutableContents.cpp"
@@ -38,6 +39,7 @@
"TranslateExecutables.cpp"
"VerifyTargetEnvironment.cpp"
DEPS
+ ::PassesIncGen
LLVMSupport
MLIRAffineToStandard
MLIRArithDialect
@@ -76,4 +78,13 @@
PUBLIC
)
+iree_tablegen_library(
+ NAME
+ PassesIncGen
+ TD_FILE
+ "Passes.td"
+ OUTS
+ --gen-pass-decls Passes.h.inc
+)
+
### BAZEL_TO_CMAKE_PRESERVES_ALL_CONTENT_BELOW_THIS_LINE ###
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/ConfigureExecutables.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/ConfigureExecutables.cpp
index ae42202..9ee5f73 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/ConfigureExecutables.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/ConfigureExecutables.cpp
@@ -11,6 +11,7 @@
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Target/TargetBackend.h"
#include "iree/compiler/Dialect/HAL/Target/TargetRegistry.h"
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
#include "iree/compiler/Utils/TracingUtils.h"
#include "llvm/ADT/StringSet.h"
#include "mlir/IR/Attributes.h"
@@ -21,42 +22,37 @@
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_CONFIGUREEXECUTABLESPASS
+#define GEN_PASS_DEF_CONFIGURETARGETEXECUTABLEVARIANTSPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
+//===----------------------------------------------------------------------===//
+// --iree-hal-configure-target-executable-variants
+//===----------------------------------------------------------------------===//
+
class ConfigureTargetExecutableVariantsPass
- : public PassWrapper<ConfigureTargetExecutableVariantsPass,
- OperationPass<IREE::HAL::ExecutableVariantOp>> {
-public:
- ConfigureTargetExecutableVariantsPass()
- : targetRegistry(TargetBackendRegistry::getGlobal()) {}
- ConfigureTargetExecutableVariantsPass(
- const ConfigureTargetExecutableVariantsPass &pass)
- : targetRegistry(pass.targetRegistry) {}
- ConfigureTargetExecutableVariantsPass(
- const TargetBackendRegistry &targetRegistry, StringRef target)
- : targetRegistry(targetRegistry) {
- this->target = target.str();
- }
-
- StringRef getArgument() const override {
- return "iree-hal-configure-target-executable-variants";
- }
-
- StringRef getDescription() const override {
- return "Configures a hal.executable.variant op for translation";
- }
+ : public IREE::HAL::impl::ConfigureTargetExecutableVariantsPassBase<
+ ConfigureTargetExecutableVariantsPass> {
+ using IREE::HAL::impl::ConfigureTargetExecutableVariantsPassBase<
+ ConfigureTargetExecutableVariantsPass>::
+ ConfigureTargetExecutableVariantsPassBase;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<IREE::HAL::HALDialect>();
- auto targetBackend = targetRegistry.getTargetBackend(target);
+ auto targetBackend = targetRegistry->getTargetBackend(target);
if (targetBackend) {
targetBackend->getDependentDialects(registry);
}
}
+
void runOnOperation() override {
auto variantOp = getOperation();
if (variantOp.getTarget().getBackend().getValue() != target)
return;
- auto targetBackend = targetRegistry.getTargetBackend(target);
+ auto targetBackend = targetRegistry->getTargetBackend(target);
if (!targetBackend) {
variantOp.emitError() << "unregistered target backend '" << target << "'";
return signalPassFailure();
@@ -78,51 +74,22 @@
return signalPassFailure();
}
}
-
-private:
- Option<std::string> target{
- *this, "target",
- llvm::cl::desc(
- "Target backend name whose executables will be configured by "
- "this pass.")};
-
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableVariantOp>>
-createConfigureTargetExecutableVariantsPass(
- const TargetBackendRegistry &targetRegistry, StringRef target) {
- return std::make_unique<ConfigureTargetExecutableVariantsPass>(targetRegistry,
- target);
-}
+//===----------------------------------------------------------------------===//
+// --iree-hal-configure-executables
+//===----------------------------------------------------------------------===//
-static PassRegistration<ConfigureTargetExecutableVariantsPass> linkTargetPass(
- [] { return std::make_unique<ConfigureTargetExecutableVariantsPass>(); });
-
-class ConfigureExecutablesPass
- : public PassWrapper<ConfigureExecutablesPass,
- OperationPass<IREE::HAL::ExecutableOp>> {
-public:
- ConfigureExecutablesPass()
- : targetRegistry(TargetBackendRegistry::getGlobal()) {}
- ConfigureExecutablesPass(const ConfigureExecutablesPass &pass)
- : targetRegistry(pass.targetRegistry) {}
- ConfigureExecutablesPass(const TargetBackendRegistry &targetRegistry)
- : targetRegistry(targetRegistry) {}
-
- StringRef getArgument() const override {
- return "iree-hal-configure-executables";
- }
-
- StringRef getDescription() const override {
- return "Configures hal.executable.variant ops for translation to "
- "hal.executable.binary ops";
- }
+struct ConfigureExecutablesPass
+ : public IREE::HAL::impl::ConfigureExecutablesPassBase<
+ ConfigureExecutablesPass> {
+ using IREE::HAL::impl::ConfigureExecutablesPassBase<
+ ConfigureExecutablesPass>::ConfigureExecutablesPassBase;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<IREE::HAL::HALDialect>();
- auto targetBackends = targetRegistry.getTargetBackends(
- targetRegistry.getRegisteredTargetBackends());
+ auto targetBackends = targetRegistry->getTargetBackends(
+ targetRegistry->getRegisteredTargetBackends());
for (auto &targetBackend : targetBackends) {
targetBackend->getDependentDialects(registry);
}
@@ -133,8 +100,8 @@
OpPassManager passManager(executableOp.getOperationName());
for (const auto &targetName : gatherExecutableTargetNames(executableOp)) {
passManager.addNestedPass<IREE::HAL::ExecutableVariantOp>(
- createConfigureTargetExecutableVariantsPass(targetRegistry,
- targetName));
+ IREE::HAL::createConfigureTargetExecutableVariantsPass(
+ {targetRegistry, targetName}));
}
IREE_COMPILER_TRACE_MESSAGE_DYNAMIC(INFO, executableOp.getSymName().str());
@@ -144,18 +111,8 @@
return signalPassFailure();
}
}
-
-private:
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createConfigureExecutablesPass(const TargetBackendRegistry &targetRegistry) {
- return std::make_unique<ConfigureExecutablesPass>(targetRegistry);
-}
-
-static PassRegistration<ConfigureExecutablesPass> translatePass([] {
- return std::make_unique<ConfigureExecutablesPass>();
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/ConvertToHAL.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/ConvertToHAL.cpp
index b140cde..6269438 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/ConvertToHAL.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/ConvertToHAL.cpp
@@ -34,32 +34,18 @@
#include "mlir/Transforms/DialectConversion.h"
namespace mlir::iree_compiler::IREE::HAL {
+
+#define GEN_PASS_DEF_CONVERTTOHALPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
namespace {
-// A pass converting the IREE flow dialect into the IREE HAL dialect.
-class ConvertToHALPass
- : public PassWrapper<ConvertToHALPass, OperationPass<ModuleOp>> {
-public:
- MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ConvertToHALPass)
+//===----------------------------------------------------------------------===//
+// --iree-hal-conversion
+//===----------------------------------------------------------------------===//
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<mlir::arith::ArithDialect>();
- registry.insert<mlir::func::FuncDialect>();
- registry.insert<mlir::scf::SCFDialect>();
- registry.insert<IREE::HAL::HALDialect>();
- registry.insert<IREE::Stream::StreamDialect>();
- registry.insert<IREE::Util::UtilDialect>();
-
- // TODO(benvanik): add a registration system for extra dialects?
- registry.insert<IREE::IO::Parameters::IOParametersDialect>();
- }
-
- StringRef getArgument() const override { return "iree-hal-conversion"; }
-
- StringRef getDescription() const override {
- return "Convert input stream/std/etc dialects to the IREE HAL dialect.";
- }
-
+struct ConvertToHALPass
+ : public IREE::HAL::impl::ConvertToHALPassBase<ConvertToHALPass> {
void runOnOperation() override {
auto *context = &getContext();
@@ -106,10 +92,4 @@
} // namespace
-std::unique_ptr<OperationPass<ModuleOp>> createConvertToHALPass() {
- return std::make_unique<ConvertToHALPass>();
-}
-
-static PassRegistration<ConvertToHALPass> pass;
-
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/DumpExecutableBenchmarks.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/DumpExecutableBenchmarks.cpp
index 5fc02a5..473c392 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/DumpExecutableBenchmarks.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/DumpExecutableBenchmarks.cpp
@@ -11,6 +11,7 @@
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
#include "iree/compiler/Dialect/Stream/IR/StreamOps.h"
+#include "iree/compiler/Dialect/Util/IR/UtilDialect.h"
#include "iree/compiler/Utils/IndexSet.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
@@ -28,6 +29,11 @@
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_DUMPEXECUTABLEBENCHMARKSPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
// We could use the resource constraints in the module when we have them.
static const int64_t kBufferAlignment = 256;
@@ -446,28 +452,15 @@
os << "\n"; // newline at end of file
}
-class DumpExecutableBenchmarksPass
- : public PassWrapper<DumpExecutableBenchmarksPass,
- OperationPass<ModuleOp>> {
-public:
- DumpExecutableBenchmarksPass() = default;
- DumpExecutableBenchmarksPass(const DumpExecutableBenchmarksPass &pass) {}
- DumpExecutableBenchmarksPass(StringRef path) { this->path = path.str(); }
+//===----------------------------------------------------------------------===//
+// --iree-hal-dump-executable-benchmarks
+//===----------------------------------------------------------------------===//
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<IREE::HAL::HALDialect>();
- registry.insert<arith::ArithDialect>();
- registry.insert<scf::SCFDialect>();
- }
-
- StringRef getArgument() const override {
- return "iree-hal-dump-executable-benchmarks";
- }
-
- StringRef getDescription() const override {
- return "Dumps standalone hal.executable benchmarks to a path.";
- }
-
+struct DumpExecutableBenchmarksPass
+ : public IREE::HAL::impl::DumpExecutableBenchmarksPassBase<
+ DumpExecutableBenchmarksPass> {
+ using IREE::HAL::impl::DumpExecutableBenchmarksPassBase<
+ DumpExecutableBenchmarksPass>::DumpExecutableBenchmarksPassBase;
void runOnOperation() override {
auto moduleOp = getOperation();
auto moduleName = moduleOp.getName().value_or("module");
@@ -519,20 +512,8 @@
}
}
}
-
-private:
- Option<std::string> path{
- *this, "path",
- llvm::cl::desc("Path to write hal.executable benchmarks into.")};
};
-std::unique_ptr<OperationPass<ModuleOp>>
-createDumpExecutableBenchmarksPass(StringRef path) {
- return std::make_unique<DumpExecutableBenchmarksPass>(path);
-}
-
-static PassRegistration<DumpExecutableBenchmarksPass> pass([] {
- return std::make_unique<DumpExecutableBenchmarksPass>();
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/DumpExecutableSources.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/DumpExecutableSources.cpp
index 6ba9c54..defca30 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/DumpExecutableSources.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/DumpExecutableSources.cpp
@@ -19,6 +19,11 @@
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_DUMPEXECUTABLESOURCESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
static void dumpExecutableToStream(IREE::HAL::ExecutableOp executableOp,
StringRef filePath, llvm::raw_ostream &os) {
OpPrintingFlags flags;
@@ -27,28 +32,15 @@
os << "\n"; // newline at end of file
}
-class DumpExecutableSourcesPass
- : public PassWrapper<DumpExecutableSourcesPass, OperationPass<ModuleOp>> {
-public:
- DumpExecutableSourcesPass() = default;
- DumpExecutableSourcesPass(const DumpExecutableSourcesPass &pass) {}
- DumpExecutableSourcesPass(StringRef path, StringRef prefix) {
- this->path = path.str();
- this->prefix = prefix.str();
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-dump-executable-sources
+//===----------------------------------------------------------------------===//
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<IREE::HAL::HALDialect>();
- }
-
- StringRef getArgument() const override {
- return "iree-hal-dump-executable-sources";
- }
-
- StringRef getDescription() const override {
- return "Dumps individual hal.executable source listings to a path.";
- }
-
+struct DumpExecutableSourcesPass
+ : public IREE::HAL::impl::DumpExecutableSourcesPassBase<
+ DumpExecutableSourcesPass> {
+ using IREE::HAL::impl::DumpExecutableSourcesPassBase<
+ DumpExecutableSourcesPass>::DumpExecutableSourcesPassBase;
void runOnOperation() override {
auto moduleOp = getOperation();
auto moduleName = moduleOp.getName().value_or("module");
@@ -88,24 +80,8 @@
executableOp.setVisibility(originalVisibility);
}
}
-
-private:
- Option<std::string> path{
- *this, "path",
- llvm::cl::desc("Path to write hal.executable source files into.")};
-
- Option<std::string> prefix{
- *this, "prefix",
- llvm::cl::desc("String to prefix the written files with.")};
};
-std::unique_ptr<OperationPass<ModuleOp>>
-createDumpExecutableSourcesPass(StringRef path, StringRef prefix) {
- return std::make_unique<DumpExecutableSourcesPass>(path, prefix);
-}
-
-static PassRegistration<DumpExecutableSourcesPass> pass([] {
- return std::make_unique<DumpExecutableSourcesPass>();
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/ElideRedundantCommands.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/ElideRedundantCommands.cpp
index 2e9cc48..77eb5bc 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/ElideRedundantCommands.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/ElideRedundantCommands.cpp
@@ -19,6 +19,10 @@
#include "mlir/Pass/Pass.h"
namespace mlir::iree_compiler::IREE::HAL {
+
+#define GEN_PASS_DEF_ELIDEREDUNDANTCOMMANDSPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
namespace {
struct DescriptorState {
@@ -82,8 +86,6 @@
using CommandBufferStateMap = DenseMap<Value, CommandBufferState>;
-} // namespace
-
static void processOp(IREE::HAL::CommandBufferExecutionBarrierOp op,
CommandBufferState &state) {
if (state.previousFullBarrier) {
@@ -201,21 +203,13 @@
return success();
}
-class ElideRedundantCommandsPass
- : public PassWrapper<ElideRedundantCommandsPass, OperationPass<void>> {
-public:
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<IREE::HAL::HALDialect>();
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-elide-redundant-commands
+//===----------------------------------------------------------------------===//
- StringRef getArgument() const override {
- return "iree-hal-elide-redundant-commands";
- }
-
- StringRef getDescription() const override {
- return "Elides stateful command buffer ops that set redundant state.";
- }
-
+struct ElideRedundantCommandsPass
+ : public IREE::HAL::impl::ElideRedundantCommandsPassBase<
+ ElideRedundantCommandsPass> {
void runOnOperation() override {
auto parentOp = getOperation();
@@ -287,10 +281,6 @@
}
};
-std::unique_ptr<OperationPass<void>> createElideRedundantCommandsPass() {
- return std::make_unique<ElideRedundantCommandsPass>();
-}
-
-static PassRegistration<ElideRedundantCommandsPass> pass;
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/FixupLegacySync.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/FixupLegacySync.cpp
index 47cfe10..0a082b7 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/FixupLegacySync.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/FixupLegacySync.cpp
@@ -4,8 +4,10 @@
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#include "iree/compiler/Dialect/HAL/IR/HALDialect.h"
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
+#include "iree/compiler/Dialect/Util/IR/UtilDialect.h"
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Attributes.h"
@@ -16,6 +18,11 @@
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_FIXUPLEGACYSYNCPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
// Marks a command buffer as being executable inline during recording.
// This is only possible because we generate our command buffer code without
// caching today and know that all are executable inline so long as we have
@@ -134,19 +141,12 @@
}
}
-// NOTE: this pass only exists for backwards compatibility with legacy HAL
-// drivers. It will be removed once all have migrated to the modern async APIs.
+//===----------------------------------------------------------------------===//
+// --iree-hal-fixup-legacy-sync
+//===----------------------------------------------------------------------===//
+
struct FixupLegacySyncPass
- : public PassWrapper<FixupLegacySyncPass, OperationPass<mlir::ModuleOp>> {
- StringRef getArgument() const override {
- return "iree-hal-fixup-legacy-sync";
- }
-
- StringRef getDescription() const override {
- return "Applies fixups to the program for when using legacy HAL devices "
- "that only support synchronous execution";
- }
-
+ : public IREE::HAL::impl::FixupLegacySyncPassBase<FixupLegacySyncPass> {
void runOnOperation() override {
auto moduleOp = getOperation();
@@ -182,10 +182,6 @@
}
};
-std::unique_ptr<OperationPass<mlir::ModuleOp>> createFixupLegacySyncPass() {
- return std::make_unique<FixupLegacySyncPass>();
-}
-
-static PassRegistration<FixupLegacySyncPass> pass;
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/LinkExecutables.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/LinkExecutables.cpp
index 8e828b6..8951945 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/LinkExecutables.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/LinkExecutables.cpp
@@ -11,6 +11,7 @@
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Target/TargetBackend.h"
#include "iree/compiler/Dialect/HAL/Target/TargetRegistry.h"
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
#include "llvm/ADT/StringSet.h"
#include "mlir/IR/Attributes.h"
#include "mlir/IR/Builders.h"
@@ -21,31 +22,25 @@
namespace mlir::iree_compiler::IREE::HAL {
-class LinkTargetExecutablesPass
- : public PassWrapper<LinkTargetExecutablesPass,
- OperationPass<mlir::ModuleOp>> {
-public:
- LinkTargetExecutablesPass()
- : targetRegistry(TargetBackendRegistry::getGlobal()) {}
- LinkTargetExecutablesPass(const LinkTargetExecutablesPass &pass)
- : targetRegistry(pass.targetRegistry) {}
- LinkTargetExecutablesPass(const TargetBackendRegistry &targetRegistry,
- StringRef target)
- : targetRegistry(targetRegistry) {
- this->target = target.str();
- }
+#define GEN_PASS_DEF_LINKEXECUTABLESPASS
+#define GEN_PASS_DEF_LINKTARGETEXECUTABLESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
- StringRef getArgument() const override {
- return "iree-hal-link-target-executables";
- }
+namespace {
- StringRef getDescription() const override {
- return "Links together hal.executables for the specified target.";
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-link-target-executables
+//===----------------------------------------------------------------------===//
+
+struct LinkTargetExecutablesPass
+ : public IREE::HAL::impl::LinkTargetExecutablesPassBase<
+ LinkTargetExecutablesPass> {
+ using IREE::HAL::impl::LinkTargetExecutablesPassBase<
+ LinkTargetExecutablesPass>::LinkTargetExecutablesPassBase;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<IREE::HAL::HALDialect>();
- auto targetBackend = targetRegistry.getTargetBackend(target);
+ auto targetBackend = targetRegistry->getTargetBackend(target);
if (targetBackend) {
targetBackend->getDependentDialects(registry);
}
@@ -53,7 +48,7 @@
void runOnOperation() override {
auto moduleOp = getOperation();
- auto targetBackend = targetRegistry.getTargetBackend(target);
+ auto targetBackend = targetRegistry->getTargetBackend(target);
if (!targetBackend) {
moduleOp.emitError() << "unregistered target backend '" << target << "'";
return signalPassFailure();
@@ -68,38 +63,16 @@
return signalPassFailure();
}
}
-
-private:
- Option<std::string> target{
- *this, "target",
- llvm::cl::desc("Target backend name whose executables will be linked by "
- "this pass.")};
-
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createLinkTargetExecutablesPass(const TargetBackendRegistry &targetRegistry,
- StringRef target) {
- return std::make_unique<LinkTargetExecutablesPass>(targetRegistry, target);
-}
+//===----------------------------------------------------------------------===//
+// --iree-hal-link-executables
+//===----------------------------------------------------------------------===//
-static PassRegistration<LinkTargetExecutablesPass> linkTargetPass([] {
- return std::make_unique<LinkTargetExecutablesPass>();
-});
-
-class LinkExecutablesPass
- : public PassWrapper<LinkExecutablesPass, OperationPass<mlir::ModuleOp>> {
-public:
- LinkExecutablesPass(const TargetBackendRegistry &targetRegistry)
- : targetRegistry(targetRegistry) {}
-
- StringRef getArgument() const override { return "iree-hal-link-executables"; }
-
- StringRef getDescription() const override {
- return "Links together hal.executables depending on target backend rules";
- }
-
+struct LinkExecutablesPass
+ : public IREE::HAL::impl::LinkExecutablesPassBase<LinkExecutablesPass> {
+ using IREE::HAL::impl::LinkExecutablesPassBase<
+ LinkExecutablesPass>::LinkExecutablesPassBase;
void runOnOperation() override {
auto moduleOp = getOperation();
@@ -107,8 +80,8 @@
// These will create/rearrange executables.
OpPassManager passManager(moduleOp.getOperationName());
for (const auto &targetName : gatherExecutableTargetNames(moduleOp)) {
- passManager.addPass(
- createLinkTargetExecutablesPass(targetRegistry, targetName));
+ passManager.addPass(IREE::HAL::createLinkTargetExecutablesPass(
+ {targetRegistry, targetName}));
}
// Cleanup any remaining empty executables after each pipeline has run.
@@ -121,18 +94,8 @@
return signalPassFailure();
}
}
-
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createLinkExecutablesPass(const TargetBackendRegistry &targetRegistry) {
- return std::make_unique<LinkExecutablesPass>(targetRegistry);
-}
-
-static PassRegistration<LinkExecutablesPass> linkPass([] {
- return std::make_unique<LinkExecutablesPass>(
- TargetBackendRegistry::getGlobal());
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeDispatchInstrumentation.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeDispatchInstrumentation.cpp
index 8c1244c..b48f7c9 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeDispatchInstrumentation.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeDispatchInstrumentation.cpp
@@ -27,6 +27,11 @@
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_MATERIALIZEDISPATCHINSTRUMENTATIONPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
static std::string getAttrStr(Attribute attr) {
if (!attr)
return "";
@@ -94,32 +99,16 @@
}
}
-class MaterializeDispatchInstrumentationPass
- : public PassWrapper<MaterializeDispatchInstrumentationPass,
- OperationPass<mlir::ModuleOp>> {
-public:
- MaterializeDispatchInstrumentationPass() = default;
- MaterializeDispatchInstrumentationPass(
- const MaterializeDispatchInstrumentationPass &pass) {}
- explicit MaterializeDispatchInstrumentationPass(int64_t bufferSize) {
- this->bufferSize = bufferSize;
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-materialize-dispatch-instrumentation
+//===----------------------------------------------------------------------===//
- StringRef getArgument() const override {
- return "iree-hal-materialize-dispatch-instrumentation";
- }
-
- StringRef getDescription() const override {
- return "Materializes dispatch instrumentation resources.";
- }
-
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<mlir::arith::ArithDialect>();
- registry.insert<IREE::HAL::HALDialect>();
- registry.insert<IREE::Stream::StreamDialect>();
- registry.insert<IREE::Util::UtilDialect>();
- }
-
+struct MaterializeDispatchInstrumentationPass
+ : public IREE::HAL::impl::MaterializeDispatchInstrumentationPassBase<
+ MaterializeDispatchInstrumentationPass> {
+ using IREE::HAL::impl::MaterializeDispatchInstrumentationPassBase<
+ MaterializeDispatchInstrumentationPass>::
+ MaterializeDispatchInstrumentationPassBase;
void runOnOperation() override {
auto moduleOp = getOperation();
if (moduleOp.getBody()->empty())
@@ -378,23 +367,8 @@
queryBuilder.create<func::ReturnOp>(loc);
}
}
-
-private:
- Option<llvm::cl::PowerOf2ByteSize> bufferSize{
- *this,
- "bufferSize",
- llvm::cl::desc("Power-of-two byte size of the instrumentation buffer."),
- llvm::cl::init(llvm::cl::PowerOf2ByteSize(64 * 1024 * 1024)),
- };
};
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createMaterializeDispatchInstrumentationPass(int64_t bufferSize) {
- return std::make_unique<MaterializeDispatchInstrumentationPass>(bufferSize);
-}
-
-static PassRegistration<MaterializeDispatchInstrumentationPass> pass([] {
- return std::make_unique<MaterializeDispatchInstrumentationPass>();
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeInterfaces.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeInterfaces.cpp
index 0b0ba53..2953df0 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeInterfaces.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeInterfaces.cpp
@@ -29,6 +29,10 @@
#define DEBUG_TYPE "iree-hal-materialize-interfaces"
namespace mlir::iree_compiler::IREE::HAL {
+
+#define GEN_PASS_DEF_MATERIALIZEINTERFACESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
namespace {
// Map of original SymbolRefAttr to a list of SymbolRefAttrs in variants.
@@ -510,28 +514,12 @@
}
//===----------------------------------------------------------------------===//
-// -iree-hal-materialize-interfaces
+// --iree-hal-materialize-interfaces
//===----------------------------------------------------------------------===//
-class MaterializeInterfacesPass
- : public PassWrapper<MaterializeInterfacesPass, OperationPass<ModuleOp>> {
-public:
- MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MaterializeInterfacesPass)
-
- MaterializeInterfacesPass() = default;
-
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<IREE::HAL::HALDialect>();
- }
-
- StringRef getArgument() const override {
- return "iree-hal-materialize-interfaces";
- }
-
- StringRef getDescription() const override {
- return "Materializes hal.executable ops from stream.executable ops";
- }
-
+struct MaterializeInterfacesPass
+ : public IREE::HAL::impl::MaterializeInterfacesPassBase<
+ MaterializeInterfacesPass> {
void runOnOperation() override {
SymbolTable symbolTable(getOperation());
@@ -656,12 +644,4 @@
} // namespace
-std::unique_ptr<OperationPass<ModuleOp>> createMaterializeInterfacesPass() {
- return std::make_unique<MaterializeInterfacesPass>();
-}
-
-static PassRegistration<MaterializeInterfacesPass> pass([] {
- return std::make_unique<MaterializeInterfacesPass>();
-});
-
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeResourceCaches.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeResourceCaches.cpp
index 3b0bb79..3620e52 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeResourceCaches.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/MaterializeResourceCaches.cpp
@@ -10,6 +10,7 @@
#include "iree/compiler/Dialect/HAL/IR/HALDialect.h"
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
+#include "iree/compiler/Dialect/Util/IR/UtilDialect.h"
#include "iree/compiler/Dialect/Util/IR/UtilOps.h"
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
@@ -22,27 +23,15 @@
namespace mlir::iree_compiler::IREE::HAL {
-class MaterializeResourceCachesPass
- : public PassWrapper<MaterializeResourceCachesPass,
- OperationPass<ModuleOp>> {
-public:
- explicit MaterializeResourceCachesPass(TargetOptions targetOptions)
- : targetOptions_(targetOptions) {}
+#define GEN_PASS_DEF_MATERIALIZERESOURCECACHESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
- StringRef getArgument() const override {
- return "iree-hal-materialize-resource-caches";
- }
+namespace {
- StringRef getDescription() const override {
- return "Materializes hal.executable resource caches and rewrites lookups.";
- }
-
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<mlir::arith::ArithDialect>();
- registry.insert<mlir::scf::SCFDialect>();
- registry.insert<IREE::HAL::HALDialect>();
- }
-
+// TODO(multi-device): rewrite this to shard resources per device.
+struct MaterializeResourceCachesPass
+ : public IREE::HAL::impl::MaterializeResourceCachesPassBase<
+ MaterializeResourceCachesPass> {
void runOnOperation() override {
auto moduleOp = getOperation();
if (moduleOp.getBody()->empty())
@@ -368,8 +357,6 @@
lookupOp.erase();
}
- TargetOptions targetOptions_;
-
OpBuilder moduleBuilder{static_cast<MLIRContext *>(nullptr)};
DenseMap<std::pair<Attribute, IREE::HAL::DescriptorSetLayoutFlags>,
IREE::Util::GlobalOp>
@@ -382,14 +369,6 @@
int nextUniqueDescriptorSetLayoutId = 0;
};
-std::unique_ptr<OperationPass<ModuleOp>>
-createMaterializeResourceCachesPass(TargetOptions targetOptions) {
- return std::make_unique<MaterializeResourceCachesPass>(targetOptions);
-}
-
-static PassRegistration<MaterializeResourceCachesPass> pass([] {
- auto options = TargetOptions::FromFlags::get();
- return std::make_unique<MaterializeResourceCachesPass>(options);
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/MemoizeDeviceQueries.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/MemoizeDeviceQueries.cpp
index 80845d3..1bc5ae0 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/MemoizeDeviceQueries.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/MemoizeDeviceQueries.cpp
@@ -6,32 +6,32 @@
#include <utility>
+#include "iree/compiler/Dialect/HAL/IR/HALDialect.h"
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
-#include "llvm/ADT/StringSet.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "iree/compiler/Dialect/Util/IR/UtilDialect.h"
#include "mlir/IR/Attributes.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Diagnostics.h"
#include "mlir/Pass/Pass.h"
-#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_MEMOIZEDEVICEQUERIESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
+//===----------------------------------------------------------------------===//
+// --iree-hal-memoize-device-queries
+//===----------------------------------------------------------------------===//
+
// NOTE: this implementation is just for a single active device. As we start to
// support multiple devices we'll need to change this to be per-device.
-class MemoizeDeviceQueriesPass
- : public PassWrapper<MemoizeDeviceQueriesPass, OperationPass<ModuleOp>> {
-public:
- StringRef getArgument() const override {
- return "iree-hal-memoize-device-queries";
- }
-
- StringRef getDescription() const override {
- return "Caches hal.device.query results for use across the entire module";
- }
-
+struct MemoizeDeviceQueriesPass
+ : public IREE::HAL::impl::MemoizeDeviceQueriesPassBase<
+ MemoizeDeviceQueriesPass> {
void runOnOperation() override {
auto moduleOp = getOperation();
@@ -119,10 +119,6 @@
}
};
-std::unique_ptr<OperationPass<ModuleOp>> createMemoizeDeviceQueriesPass() {
- return std::make_unique<MemoizeDeviceQueriesPass>();
-}
-
-static PassRegistration<MemoizeDeviceQueriesPass> pass;
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.cpp
index ebdb4f3..1073e71 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.cpp
@@ -138,6 +138,10 @@
using FunctionLikeNest = MultiOpNest<func::FuncOp, IREE::Util::InitializerOp>;
+//===----------------------------------------------------------------------===//
+// Utilities
+//===----------------------------------------------------------------------===//
+
static void addCleanupPatterns(OpPassManager &passManager) {
// Standard MLIR cleanup.
passManager.addPass(mlir::createCSEPass());
@@ -155,6 +159,27 @@
passManager.addPass(IREE::Util::createFuseGlobalsPass());
}
+static void addExecutableSubstitutionPasses(OpPassManager &passManager,
+ ArrayRef<std::string> substitutions,
+ StringRef fromPath) {
+ if (!fromPath.empty()) {
+ SubstituteExecutablesPassOptions substituteOptions;
+ substituteOptions.searchPath = fromPath;
+ passManager.addPass(
+ IREE::HAL::createSubstituteExecutablesPass(substituteOptions));
+ }
+ if (!substitutions.empty()) {
+ SubstituteExecutablesPassOptions substituteOptions;
+ substituteOptions.substitutions = substitutions;
+ passManager.addPass(
+ IREE::HAL::createSubstituteExecutablesPass(substituteOptions));
+ }
+}
+
+//===----------------------------------------------------------------------===//
+// --iree-hal-configuration-pipeline
+//===----------------------------------------------------------------------===//
+
void buildHALConfigurationPassPipeline(
OpPassManager &passManager, const TargetBackendRegistry &targetRegistry,
const TargetOptions &targetOptions) {
@@ -178,29 +203,30 @@
// Today we just assign devices from parameters but we should instead be
// performing analysis at the flow level and then doing magic device
// database lookups here.
- passManager.addPass(
- createAssignTargetDevicesPass(targetRegistry, targetOptions.targets));
+ passManager.addPass(IREE::HAL::createAssignTargetDevicesPass(
+ {&targetRegistry, targetOptions.targets}));
}
- passManager.addPass(createVerifyTargetEnvironmentPass(targetRegistry));
+ passManager.addPass(
+ IREE::HAL::createVerifyTargetEnvironmentPass({targetRegistry}));
// Add dispatch instrumentation prior to materializing interfaces so we can
// more easily mutate the stream dispatch ops and exports.
if (auto bufferSize = clInstrumentDispatchBufferSize.getValue()) {
- passManager.addPass(
- createMaterializeDispatchInstrumentationPass(bufferSize.value));
+ passManager.addPass(IREE::HAL::createMaterializeDispatchInstrumentationPass(
+ {bufferSize.value}));
}
// Each executable needs a hal.interface to specify how the host and
// device communicate across the ABI boundary.
- passManager.addPass(createMaterializeInterfacesPass());
+ passManager.addPass(IREE::HAL::createMaterializeInterfacesPass());
// Dump a source listing of each hal.executable and update the source
// locations in the IR. This will allow us to easily inspect each executable
// and give downstream tools that can display source information something
// more useful and slim than the entire original source model.
if (!targetOptions.executableSourcesPath.empty()) {
- passManager.addPass(
- createDumpExecutableSourcesPass(targetOptions.executableSourcesPath));
+ passManager.addPass(IREE::HAL::createDumpExecutableSourcesPass(
+ {targetOptions.executableSourcesPath}));
}
// Substitute hal.executables we've generated from earlier phases of
@@ -209,15 +235,12 @@
// in various forms without modifying the end-to-end compiler. Note that we do
// this prior to dumping benchmarks in order to allow generating new
// benchmarks using the substituted executables.
- if (!clSubstituteExecutableSourcesFrom.empty()) {
- passManager.addPass(createSubstituteExecutablesPass(
- clSubstituteExecutableSourcesFrom.getValue()));
- }
- if (!clSubstituteExecutableSource.empty()) {
- passManager.addPass(
- createSubstituteExecutablesPass(clSubstituteExecutableSource));
- }
+ addExecutableSubstitutionPasses(passManager, clSubstituteExecutableSource,
+ clSubstituteExecutableSourcesFrom);
}
+//===----------------------------------------------------------------------===//
+// --iree-hal-transformation-pipeline
+//===----------------------------------------------------------------------===//
void buildHALTransformPassPipeline(OpPassManager &passManager,
const TargetBackendRegistry &targetRegistry,
@@ -241,7 +264,7 @@
// more variants and even insert or remove variants.
for (auto command : clPreprocessExecutablesWith) {
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
- createPreprocessExecutablesPass(command));
+ IREE::HAL::createPreprocessExecutablesPass(command));
}
}
@@ -259,30 +282,21 @@
// selected translation strategies and the features each translation
// strategy are known to require or not require.
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
- createConfigureExecutablesPass(targetRegistry));
+ IREE::HAL::createConfigureExecutablesPass({targetRegistry}));
// Dump a second listing of each hal.executable after preprocessing and
// configuration of executables, as well as update locations in the IR.
if (!targetOptions.executableConfigurationsPath.empty()) {
- passManager.addPass(createDumpExecutableSourcesPass(
- targetOptions.executableConfigurationsPath, "configured"));
+ passManager.addPass(IREE::HAL::createDumpExecutableSourcesPass(
+ {targetOptions.executableConfigurationsPath, "configured"}));
}
- if (!clSubstituteExecutableConfiguration.empty()) {
- passManager.addPass(
- createSubstituteExecutablesPass(clSubstituteExecutableConfiguration));
- }
// Substitute hal.executables we've configured with those specified on the
// command line. This developer feature allows for hand editing the
// configured executable with different lowering parameters.
- if (!clSubstituteExecutableConfigurationsFrom.empty()) {
- passManager.addPass(createSubstituteExecutablesPass(
- clSubstituteExecutableConfigurationsFrom.getValue()));
- }
- if (!clSubstituteExecutableConfiguration.empty()) {
- passManager.addPass(
- createSubstituteExecutablesPass(clSubstituteExecutableConfiguration));
- }
+ addExecutableSubstitutionPasses(passManager,
+ clSubstituteExecutableConfiguration,
+ clSubstituteExecutableConfigurationsFrom);
// Dump standalone hal.executable benchmark modules.
// Today this only works for executables that have static dispatch
@@ -290,8 +304,8 @@
// after configuration to make it easy to tweak configurations directly
// from the benchmark.
if (!targetOptions.executableBenchmarksPath.empty()) {
- passManager.addPass(createDumpExecutableBenchmarksPass(
- targetOptions.executableBenchmarksPath));
+ passManager.addPass(IREE::HAL::createDumpExecutableBenchmarksPass(
+ {targetOptions.executableBenchmarksPath}));
}
}
@@ -311,7 +325,7 @@
if (compileFrom < PipelinePhase::ExecutableTargets) {
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
- createTranslateExecutablesPass(targetRegistry));
+ IREE::HAL::createTranslateExecutablesPass({targetRegistry}));
}
if (compileTo == PipelinePhase::ExecutableTargets)
@@ -324,25 +338,19 @@
// but sometimes translation is required to produce the host code required
// for specialization and workgroup counts and we need to perform the
// substitution later.
- if (!clSubstituteExecutableObjectsFrom.empty()) {
- passManager.addPass(createSubstituteExecutablesPass(
- clSubstituteExecutableObjectsFrom.getValue()));
- }
- if (!clSubstituteExecutableObject.empty()) {
- passManager.addPass(
- createSubstituteExecutablesPass(clSubstituteExecutableObject));
- }
+ addExecutableSubstitutionPasses(passManager, clSubstituteExecutableObject,
+ clSubstituteExecutableObjectsFrom);
//----------------------------------------------------------------------------
// Host program conversion
//----------------------------------------------------------------------------
// Convert supported input dialects (std, stream, etc) into the HAL dialect.
- passManager.addPass(createConvertToHALPass());
+ passManager.addPass(IREE::HAL::createConvertToHALPass());
// If any devices require the legacy synchronous execution behavior then
// make all async operations blocking.
- passManager.addPass(createFixupLegacySyncPass());
+ passManager.addPass(IREE::HAL::createFixupLegacySyncPass());
addCleanupPatterns(passManager);
@@ -358,17 +366,17 @@
// same architecture into a single executable and link it as a shared
// library.
if (transformOptions.linkExecutables) {
- passManager.addPass(createLinkExecutablesPass(targetRegistry));
+ passManager.addPass(IREE::HAL::createLinkExecutablesPass({targetRegistry}));
}
// Resolve export ordinals from nested symbol references prior to
// serialization. As this pass creates lookup ops it should run before
// MaterializeResourceCachesPass.
- passManager.addPass(createResolveExportOrdinalsPass());
+ passManager.addPass(IREE::HAL::createResolveExportOrdinalsPass());
// Gather cacheable resources such as executables and descriptor sets and
// cache them at initialization-time.
- passManager.addPass(createMaterializeResourceCachesPass(targetOptions));
+ passManager.addPass(IREE::HAL::createMaterializeResourceCachesPass());
//----------------------------------------------------------------------------
// Device management and specialization
@@ -376,19 +384,24 @@
// Memoize device queries such that we don't need to repeatedly ask the same
// information at runtime.
- passManager.addPass(createMemoizeDeviceQueriesPass());
+ passManager.addPass(IREE::HAL::createMemoizeDeviceQueriesPass());
// Big cleanup after all our conversion and materialization.
addCleanupPatterns(passManager);
- // HACK: repeat dispatch ops for benchmarks.
+ // Benchmarking only: repeat dispatch ops a certain number of times.
+ // This is guaranteed to invalidate program output and may introduce crashes
+ // if there are in-place dispatches that expect specific input data.
if (clBenchmarkDispatchRepeatCount != 1) {
- passManager.addNestedPass<mlir::func::FuncOp>(
- createBenchmarkBatchDispatchesPass(clBenchmarkDispatchRepeatCount));
+ FunctionLikeNest(passManager).addPass([&]() {
+ return IREE::HAL::createRepeatDispatchesPass(
+ {clBenchmarkDispatchRepeatCount});
+ });
}
// Elide redundant command buffer state ops created during conversion.
- FunctionLikeNest(passManager).addPass(createElideRedundantCommandsPass);
+ FunctionLikeNest(passManager)
+ .addPass(IREE::HAL::createElideRedundantCommandsPass);
// Fixup workgroup count calculations that may have used the affine dialect.
// Kind of random here but can happen if the benchmarking code does things.
@@ -410,10 +423,10 @@
// contents not turned into a big base64 string.
if (transformOptions.serializeExecutables) {
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
- createSerializeExecutablesPass(
- targetRegistry, targetOptions.debugLevel,
- targetOptions.executableIntermediatesPath,
- targetOptions.executableBinariesPath));
+ IREE::HAL::createSerializeExecutablesPass(
+ {&targetRegistry, targetOptions.debugLevel,
+ targetOptions.executableIntermediatesPath,
+ targetOptions.executableBinariesPath}));
// NOTE: symbol DCE will destroy executable target contents, so only run
// it if we serialized things.
@@ -457,21 +470,35 @@
transformOptions, compileFrom, compileTo);
}
-void registerHALConfigurationPassPipeline() {
+//===----------------------------------------------------------------------===//
+// Registration
+//===----------------------------------------------------------------------===//
+
+namespace {
+#define GEN_PASS_REGISTRATION
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc" // IWYU pragma: export
+} // namespace
+
+void registerHALPasses() {
+ // Force the flags to be bound.
+ // TODO(benvanik): remove the global flags and only rely on pipeline flags.
+ (void)IREE::HAL::TargetOptions::FromFlags::get();
+
+ // Generated.
+ registerPasses();
+
+ // Pipelines.
PassPipelineRegistration<>("iree-hal-configuration-pipeline",
- "Runs the IREE HAL dialect configuration pipeline",
+ "Runs HAL target configuration pipeline.",
[](OpPassManager &passManager) {
buildHALConfigurationPassPipeline(
passManager,
TargetBackendRegistry::getGlobal(),
TargetOptions::FromFlags::get());
});
-}
-
-void registerHALTransformPassPipeline() {
PassPipelineRegistration<TransformOptions>(
"iree-hal-transformation-pipeline",
- "Runs the full IREE HAL dialect transformation pipeline",
+ "Runs the full IREE HAL conversion/lowering pipeline.",
[](OpPassManager &passManager, const TransformOptions &transformOptions) {
buildHALTransformPassPipeline(
passManager, TargetBackendRegistry::getGlobal(),
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.h b/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.h
index 97778d1..18050b9 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.h
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.h
@@ -20,7 +20,7 @@
namespace mlir::iree_compiler::IREE::HAL {
//===----------------------------------------------------------------------===//
-// Helpers
+// Pipelines
//===----------------------------------------------------------------------===//
enum class PipelinePhase {
@@ -37,6 +37,13 @@
End,
};
+// Adds a set of passes to the given pass manager that run the head of the HAL
+// pipeline to assign devices, materialize interfaces, and translate
+// executables. The host portion of the program is annotated but not modified.
+void buildHALConfigurationPassPipeline(
+ OpPassManager &passManager, const TargetBackendRegistry &targetRegistry,
+ const TargetOptions &targetOptions);
+
// Adds a set of passes to the given pass manager that run the required HAL
// transforms in the canonical order.
//
@@ -53,193 +60,22 @@
PipelinePhase compileFrom = PipelinePhase::Start,
PipelinePhase compileTo = PipelinePhase::End);
-// Adds a set of passes to the given pass manager that run the head of the HAL
-// pipeline to assign devices, materialize interfaces, and translate
-// executables. The host portion of the program is annotated but not modified.
-void buildHALConfigurationPassPipeline(
- OpPassManager &passManager, const TargetBackendRegistry &targetRegistry,
- const TargetOptions &targetOptions);
-
-void registerHALTransformPassPipeline();
-void registerHALConfigurationPassPipeline();
-
//===----------------------------------------------------------------------===//
-// Conversion
+// Passes
//===----------------------------------------------------------------------===//
-// Converts input flow/std/etc dialects to the IREE HAL dialect.
-std::unique_ptr<OperationPass<mlir::ModuleOp>> createConvertToHALPass();
-
-//===----------------------------------------------------------------------===//
-// Device management
-//===----------------------------------------------------------------------===//
-
-// Verifies that the target execution environment is valid.
-// #hal.device.target and #hal.executable.target attribute placement and
-// definition will be checked as well along with other structural requirements.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createVerifyTargetEnvironmentPass(const TargetBackendRegistry &targetRegistry);
-
-// Assigns the HAL devices the module will target to the given list of targets.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createAssignTargetDevicesPass(const TargetBackendRegistry &targetRegistry,
- ArrayRef<std::string> targets);
-
-// Applies fixups to the program for when using legacy HAL devices that only
-// support synchronous execution. Once all devices support async this will be
-// removed.
-std::unique_ptr<OperationPass<mlir::ModuleOp>> createFixupLegacySyncPass();
-
-// Finds hal.device.query ops and creates variables initialized on startup.
-std::unique_ptr<OperationPass<mlir::ModuleOp>> createMemoizeDeviceQueriesPass();
-
-//===----------------------------------------------------------------------===//
-// Executable translation
-//===----------------------------------------------------------------------===//
-
-// Defines hal.executables and hal.interfaces for flow.executable ops based on
-// usage within the module. Target backends are queried to check for support and
-// device placements are made.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createMaterializeInterfacesPass();
-
-// Dumps individual hal.executable source listings to |path|.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createDumpExecutableSourcesPass(StringRef path, StringRef prefix = "");
-
-// Dumps standalone hal.executable benchmarks to |path|.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createDumpExecutableBenchmarksPass(StringRef path);
-
-// Strips executable module contents for reducing IR size during debugging.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createStripExecutableContentsPass();
-
-// Substitutes hal.executable ops by parsing |substitutions| in
-// `executable_name=file.xxx` strings. File paths may be absolute or relative to
-// the paths specified on `--iree-hal-executable-object-search-path=`.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createSubstituteExecutablesPass(ArrayRef<std::string> substitutions = {});
-// Substitutes hal.executable ops with files in the given |searchPath| matching
-// the symbol name.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createSubstituteExecutablesPass(std::string searchPath);
-
-// Preprocess each executable with either a pass pipeline or external tool.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createPreprocessExecutablesPass(std::string command);
-// Preprocesses each executable with a pass pipeline.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createPreprocessExecutablesWithPipelinePass(std::string pipeline);
-// Preprocesses each executable with an external tool.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createPreprocessExecutablesWithToolPass(std::string command);
-
-// Configures hal.executable.variant ops in all hal.executable ops via a nested
-// translation pipeline.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createConfigureExecutablesPass(const TargetBackendRegistry &targetRegistry);
-
-// Configures hal.executable.variant ops for the specified |target| backend.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableVariantOp>>
-createConfigureTargetExecutableVariantsPass(
- const TargetBackendRegistry &targetRegistry, StringRef target);
-
-// Translates hal.executable.variant ops via a nested translation pipeline.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createTranslateExecutablesPass(const TargetBackendRegistry &targetRegistry);
-
-// Translates hal.executable.variant ops for the specified |target| backend.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableVariantOp>>
-createTranslateTargetExecutableVariantsPass(
- const TargetBackendRegistry &targetRegistry, StringRef target);
-
-// Calls into each target backend to have it link multiple hal.executables
-// together (if that makes sense). For example, the LLVM AOT backend may combine
-// all executable targets for the same architecture into a single executable and
-// link it as a shared library.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createLinkExecutablesPass(const TargetBackendRegistry &targetRegistry);
-
-// Links executables for the specified |target| backend.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createLinkTargetExecutablesPass(const TargetBackendRegistry &targetRegistry,
- StringRef target);
-
-// Resolves hal.executable.export references to ordinals.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createResolveExportOrdinalsPass();
-
-// Converts hal.executable.variants to one or more hal.executable.binary ops.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createSerializeExecutablesPass(const TargetBackendRegistry &targetRegistry,
- int debugLevel = 2,
- std::string dumpIntermediatesPath = "",
- std::string dumpBinariesPath = "");
-
-// Serializes executables for the specified |target| backend.
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createSerializeTargetExecutablesPass(
- const TargetBackendRegistry &targetRegistry, StringRef target,
- int debugLevel = 2, std::string dumpIntermediatesPath = "",
- std::string dumpBinariesPath = "");
-
-//===----------------------------------------------------------------------===//
-// Resource initialization, caching, and optimization
-//===----------------------------------------------------------------------===//
-
-// Materializes host and device dispatch instrumentation resources on stream IR.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createMaterializeDispatchInstrumentationPass(int64_t bufferSize);
-
-// Finds all resource lookups (such as hal.executable.lookup), materializes
-// their cache storage and initialization, and rewrites the lookups to
-// references.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createMaterializeResourceCachesPass(TargetOptions targetOptions);
-
-// Elides stateful command buffer ops that set redundant state.
-std::unique_ptr<OperationPass<void>> createElideRedundantCommandsPass();
-
-// Repeats dispatches `iree-hal-repeat-dispatch-num` times, which is 1 by
-// default.
-std::unique_ptr<OperationPass<func::FuncOp>>
-createBenchmarkBatchDispatchesPass(unsigned repeatCount);
+// Preprocesses each executable with an MLIR pass pipeline or external command
+// line tool.
+std::unique_ptr<Pass> createPreprocessExecutablesPass(std::string command = "");
//===----------------------------------------------------------------------===//
// Register all Passes
//===----------------------------------------------------------------------===//
-inline void registerHALPasses() {
- registerHALTransformPassPipeline();
- registerHALConfigurationPassPipeline();
- auto targetOptions = TargetOptions::FromFlags::get();
- createAssignTargetDevicesPass(TargetBackendRegistry::getGlobal(), {});
- createBenchmarkBatchDispatchesPass(/*repeatCount=*/1);
- createConfigureExecutablesPass(TargetBackendRegistry::getGlobal());
- createConfigureTargetExecutableVariantsPass(
- TargetBackendRegistry::getGlobal(), "");
- createConvertToHALPass();
- createDumpExecutableSourcesPass("");
- createElideRedundantCommandsPass();
- createFixupLegacySyncPass();
- createLinkExecutablesPass(TargetBackendRegistry::getGlobal());
- createLinkTargetExecutablesPass(TargetBackendRegistry::getGlobal(), "");
- createMaterializeDispatchInstrumentationPass(0);
- createMaterializeInterfacesPass();
- createMaterializeResourceCachesPass(targetOptions);
- createMemoizeDeviceQueriesPass();
- createPreprocessExecutablesPass("");
- createResolveExportOrdinalsPass();
- createSerializeExecutablesPass(TargetBackendRegistry::getGlobal());
- createSerializeTargetExecutablesPass(TargetBackendRegistry::getGlobal(), "");
- createStripExecutableContentsPass();
- createSubstituteExecutablesPass();
- createTranslateExecutablesPass(TargetBackendRegistry::getGlobal());
- createTranslateTargetExecutableVariantsPass(
- TargetBackendRegistry::getGlobal(), "");
- createVerifyTargetEnvironmentPass(TargetBackendRegistry::getGlobal());
-}
+#define GEN_PASS_DECL
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc" // IWYU pragma: keep
+
+void registerHALPasses();
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.td b/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.td
new file mode 100644
index 0000000..0c8f376
--- /dev/null
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/Passes.td
@@ -0,0 +1,562 @@
+// Copyright 2023 The IREE Authors
+//
+// Licensed 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
+
+#ifndef IREE_DIALECT_HAL_PASSES
+#define IREE_DIALECT_HAL_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+//===----------------------------------------------------------------------===//
+// Conversion
+//===----------------------------------------------------------------------===//
+
+def ConvertToHALPass :
+ Pass<"iree-hal-conversion", "mlir::ModuleOp"> {
+ let summary = "Converts from stream and other intermediate dialects into the hal dialect.";
+ let description = [{
+ Converts supported intermediate dialects (`stream`, `util`, and various
+ upstream dialects like `cf`/`scf`) into the hal dialect. After conversion
+ host code scheduling work and allocations will act on `!hal.device` queues
+ and `!hal.buffer` (and other) resources.
+
+ It's expected that executable interface materialization has been performed
+ so that the information required to marshal buffers and operands to the
+ device is available for conversion.
+ }];
+ let dependentDialects = [
+ "mlir::arith::ArithDialect",
+ "mlir::func::FuncDialect",
+ "mlir::scf::SCFDialect",
+ "IREE::HAL::HALDialect",
+ "IREE::Stream::StreamDialect",
+ "IREE::Util::UtilDialect",
+ // TODO(benvanik): add a registration system for extra dialects?
+ "IREE::IO::Parameters::IOParametersDialect",
+ ];
+}
+
+//===----------------------------------------------------------------------===//
+// Device management
+//===----------------------------------------------------------------------===//
+
+def VerifyTargetEnvironmentPass :
+ Pass<"iree-hal-verify-target-environment", "mlir::ModuleOp"> {
+ let summary = "Verifies that the target execution environment is valid.";
+ let description = [{
+ Verifies that the target execution environment is valid.
+ `#hal.device.target` and `#hal.executable.target` attribute placement and
+ definition will be checked that they reference the available target backends
+ and that they are structurally valid.
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ ];
+}
+
+def AssignTargetDevicesPass :
+ Pass<"iree-hal-assign-target-devices", "mlir::ModuleOp"> {
+ let summary = "Assigns the HAL devices the module will target to the given list of targets.";
+ let description = [{
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ ListOption<
+ "targets", "targets",
+ "std::string",
+ "List of devices to assign as targets."
+ >,
+ ];
+}
+
+def FixupLegacySyncPass :
+ Pass<"iree-hal-fixup-legacy-sync", "mlir::ModuleOp"> {
+ let summary = "Applies fixups to the program for when using legacy HAL devices.";
+ let description = [{
+ Applies fixups to the program for when using legacy HAL devices that only
+ support synchronous execution. Once all devices support async this will be
+ removed.
+
+ NOTE: this pass only exists for backwards compatibility with legacy HAL
+ drivers. It will be removed once all have migrated to the modern async APIs.
+ }];
+ let dependentDialects = [
+ "mlir::arith::ArithDialect",
+ "IREE::HAL::HALDialect",
+ "IREE::Util::UtilDialect",
+ ];
+}
+
+def MemoizeDeviceQueriesPass :
+ Pass<"iree-hal-memoize-device-queries", "mlir::ModuleOp"> {
+ let summary = "Finds hal.device.query ops and creates variables initialized on startup.";
+ let description = [{
+ Finds all `hal.device.query`-related ops that are hoistable and moves them
+ into globals that are initialized on startup. This prevents repeated queries
+ at runtime and allows for optimization as queries are CSEd across the entire
+ program.
+ }];
+ let dependentDialects = [
+ "mlir::arith::ArithDialect",
+ "IREE::HAL::HALDialect",
+ "IREE::Util::UtilDialect",
+ ];
+}
+
+//===----------------------------------------------------------------------===//
+// Executable translation
+//===----------------------------------------------------------------------===//
+
+def MaterializeInterfacesPass :
+ Pass<"iree-hal-materialize-interfaces", "mlir::ModuleOp"> {
+ let summary = "Defines hal.executable variants for stream.executable ops.";
+ let description = [{
+ Defines hal.executables and one hal.variant for each required target. The
+ interfaces required to marshal buffers and operands across the host-device
+ boundary are declared on the executables and annotated on the dispatch
+ sites so that subsequent conversion can consume them.
+ }];
+ let dependentDialects = [
+ "mlir::arith::ArithDialect",
+ "IREE::HAL::HALDialect",
+ ];
+}
+
+def SubstituteExecutablesPass :
+ Pass<"iree-hal-substitute-executables", "mlir::ModuleOp"> {
+ let summary = "Substitutes hal.executable ops with files on disk.";
+ let description = [{
+ Substitutes hal.executable ops with externally referenced MLIR files or
+ target-specific object files. When provided a .mlir/.mlirbc file with a
+ top-level hal.executable the entire executable will be replaced including
+ all variants contained with. All other files such as .o, .bc, and .spv will
+ be set as external object files on the original executable variants and the
+ original contents will be dropped.
+
+ Substitutions can be specified by providing a file system path where there
+ exists files matching the executable names in one of the supported formats
+ or by specifying the file each executable name maps to directly.
+ }];
+ let options = [
+ ListOption<
+ "substitutions", "substitutions",
+ "std::string",
+ "Substitution `executable_name=file.xxx` key-value pairs."
+ >,
+ Option<
+ "searchPath", "search-path",
+ "std::string", "",
+ "Path to source executable substitutions from."
+ >,
+ ];
+ let dependentDialects = [
+ // NOTE: we may need more for anything we load from MLIR files.
+ "IREE::HAL::HALDialect",
+ ];
+}
+
+def PreprocessExecutablesWithPipelinePass :
+ Pass<"iree-hal-preprocess-executables-with-pipeline", "IREE::HAL::ExecutableOp"> {
+ let summary = "Preprocess each executable with an MLIR pass pipeline.";
+ let description = [{
+ Runs the given MLIR pass pipeline as parsed by the `--pass-pipeline=` flag
+ on each hal.executable in the program. The passes must be linked into the
+ compiler to be discovered.
+ }];
+ let options = [
+ Option<
+ "pipeline", "pipeline",
+ "std::string", "",
+ "MLIR pass pipeline description to run on each executable."
+ >,
+ ];
+}
+
+def PreprocessExecutablesWithToolPass :
+ Pass<"iree-hal-preprocess-executables-with-tool", "IREE::HAL::ExecutableOp"> {
+ let summary = "Preprocess each executable with an external command line tool.";
+ let description = [{
+ Passes each hal.executable in the program to the given command line tool
+ as stdin and parses the resulting MLIR from stdout to replace them. This
+ is equivalent to `iree-hal-preprocess-executables-with-pipeline` but allows
+ for an external `mlir-opt`/`iree-opt`-like tool to be used containing the
+ pipelines instead of requiring the passes to be linked into the compiler.
+ }];
+ let options = [
+ Option<
+ "command", "command",
+ "std::string", "",
+ "stdin->stdout command to run on each hal.executable MLIR op."
+ >,
+ ];
+}
+
+def ConfigureExecutablesPass :
+ Pass<"iree-hal-configure-executables", "IREE::HAL::ExecutableOp"> {
+ let summary = "Configures hal.executable ops via a nested translation pipeline.";
+ let description = [{
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ ];
+}
+
+def ConfigureTargetExecutableVariantsPass :
+ Pass<"iree-hal-configure-target-executable-variants", "IREE::HAL::ExecutableVariantOp"> {
+ let summary = "Configures hal.executable.variant ops for the specified target backend.";
+ let description = [{
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ Option<
+ "target", "target",
+ "std::string", "",
+ "Target backend name whose executable variants will be configured by this pass."
+ >,
+ ];
+}
+
+def TranslateExecutablesPass :
+ Pass<"iree-hal-translate-executables", "IREE::HAL::ExecutableOp"> {
+ let summary = "Translates hal.executable ops via a nested translation pipeline.";
+ let description = [{
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ ];
+}
+
+def TranslateTargetExecutableVariantsPass :
+ Pass<"iree-hal-translate-target-executable-variants", "IREE::HAL::ExecutableVariantOp"> {
+ let summary = "Translates hal.executable.variant ops for the specified target backend.";
+ let description = [{
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ Option<
+ "target", "target",
+ "std::string", "",
+ "Target backend name whose executable variants will be translated by this pass."
+ >,
+ ];
+}
+
+def LinkExecutablesPass :
+ Pass<"iree-hal-link-executables", "mlir::ModuleOp"> {
+ let summary = "Links hal.executable ops into one or more hal.executable ops.";
+ let description = [{
+ Calls into each target backend to have it link multiple `hal.executable` ops
+ together (if the backend desires).
+
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ ];
+}
+
+def LinkTargetExecutablesPass :
+ Pass<"iree-hal-link-target-executables", "mlir::ModuleOp"> {
+ let summary = "Links executables for the specified target backend.";
+ let description = [{
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ Option<
+ "target", "target",
+ "std::string", "",
+ "Target backend name whose executables will be linked by this pass."
+ >,
+ ];
+}
+
+def ResolveExportOrdinalsPass :
+ Pass<"iree-hal-resolve-export-ordinals", "mlir::ModuleOp"> {
+ let summary = "Resolves symbolic hal.executable.export references to ordinals.";
+ let description = [{
+ Severs symbolic references to hal.executable.export ops from dispatch sites
+ by replacing them with the ordinal assigned to the exports. This allows for
+ subsequent passes to collapse the executables into opaque blobs.
+ }];
+ let dependentDialects = [
+ "IREE::HAL::HALDialect",
+ ];
+}
+
+def SerializeExecutablesPass :
+ Pass<"iree-hal-serialize-executables", "IREE::HAL::ExecutableOp"> {
+ let summary = "Converts hal.executable.variants to one or more hal.executable.binary ops.";
+ let description = [{
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ Option<
+ "debugLevel", "debug-level",
+ "int", "2",
+ "Debug level for serialization (0 (no information) to 3 (all information))."
+ >,
+ Option<
+ "dumpIntermediatesPath", "dump-intermediates-path",
+ "std::string", "",
+ "Path to write translated executable intermediates (.bc, .o, etc) into for debugging."
+ >,
+ Option<
+ "dumpBinariesPath", "dump-binaries-path",
+ "std::string", "",
+ "Path to write translated and serialized executable binaries into for debugging."
+ >,
+ ];
+}
+
+def SerializeTargetExecutablesPass :
+ Pass<"iree-hal-serialize-target-executables", "IREE::HAL::ExecutableOp"> {
+ let summary = "Serializes executables for the specified target backend.";
+ let description = [{
+ DO NOT SUBMIT
+ }];
+ let options = [
+ Option<
+ "targetRegistry", "target-registry",
+ "llvm::cl::TargetBackendRegistryRef", "",
+ "Target backend registry containing the list of available backends."
+ >,
+ Option<
+ "target", "target",
+ "std::string", "",
+ "Target backend name whose executables will be serialized by this pass."
+ >,
+ Option<
+ "debugLevel", "debug-level",
+ "int", "2",
+ "Debug level for serialization (0 (no information) to 3 (all information))."
+ >,
+ Option<
+ "dumpIntermediatesPath", "dump-intermediates-path",
+ "std::string", "",
+ "Path to write translated executable intermediates (.bc, .o, etc) into for debugging."
+ >,
+ Option<
+ "dumpBinariesPath", "dump-binaries-path",
+ "std::string", "",
+ "Path to write translated and serialized executable binaries into for debugging."
+ >,
+ ];
+}
+
+//===----------------------------------------------------------------------===//
+// Resource initialization, caching, and optimization
+//===----------------------------------------------------------------------===//
+
+def MaterializeDispatchInstrumentationPass :
+ Pass<"iree-hal-materialize-dispatch-instrumentation", "mlir::ModuleOp"> {
+ let summary = "Materializes host and device dispatch instrumentation resources on stream IR.";
+ let description = [{
+ Adds dispatch instrumentation for both host and device prior to
+ materializing interfaces so that the higher-level stream dialect can be used
+ to easily mutate the dispatch sites, executable exports, and resources used
+ for instrumentation storage.
+ }];
+ let options = [
+ Option<
+ "bufferSize", "buffer-size",
+ "llvm::cl::PowerOf2ByteSize", "llvm::cl::PowerOf2ByteSize(64 * 1024 * 1024)",
+ "Power-of-two byte size of the instrumentation buffer."
+ >,
+ ];
+ let dependentDialects = [
+ "mlir::arith::ArithDialect",
+ "mlir::func::FuncDialect",
+ "IREE::HAL::HALDialect",
+ "IREE::Stream::StreamDialect",
+ "IREE::Util::UtilDialect",
+ ];
+}
+
+def MaterializeResourceCachesPass :
+ Pass<"iree-hal-materialize-resource-caches", "mlir::ModuleOp"> {
+ let summary = "Materializes cached globals for device resources.";
+ let description = [{
+ Scans the program for resource lookups such as `hal.executable.lookup` and
+ materializes globals initialized on startup. The original lookup ops are
+ replaced with global loads of the cached resources.
+ }];
+ let dependentDialects = [
+ "mlir::arith::ArithDialect",
+ "mlir::func::FuncDialect",
+ "mlir::scf::SCFDialect",
+ "IREE::HAL::HALDialect",
+ "IREE::Util::UtilDialect",
+ ];
+}
+
+def ElideRedundantCommandsPass :
+ Pass<"iree-hal-elide-redundant-commands", ""> {
+ let summary = "Elides stateful command buffer ops that set redundant state.";
+ let description = [{
+ Identifies sequences of stateful command buffer operations such as
+ `hal.command_buffer.push_descriptor_set` that set redundant state that arise
+ from trivial conversion from the stateless stream dialect and removes them
+ to reduce binary size and runtime overhead.
+ }];
+ let dependentDialects = [
+ "IREE::HAL::HALDialect",
+ ];
+}
+
+//===----------------------------------------------------------------------===//
+// Benchmarking and debugging utilities
+//===----------------------------------------------------------------------===//
+
+def DumpExecutableSourcesPass :
+ Pass<"iree-hal-dump-executable-sources", "mlir::ModuleOp"> {
+ let summary = "Dumps individual hal.executable source listings to the provided path.";
+ let description = [{
+ Dumps a source listing of each hal.executable and updates the source
+ locations in the IR to point at the produced files. This allows for easy
+ inspection of each executable prior to translation and gives downstream
+ tools that can display source information (Tracy, perf, etc) something more
+ useful than the entire original source program.
+ }];
+ let options = [
+ Option<
+ "path", "path",
+ "std::string", "",
+ "File system path to write each executable source MLIR file."
+ >,
+ Option<
+ "prefix", "prefix",
+ "std::string", "",
+ "String to prefix the written file names with."
+ >,
+ ];
+}
+
+def DumpExecutableBenchmarksPass :
+ Pass<"iree-hal-dump-executable-benchmarks", "mlir::ModuleOp"> {
+ let summary = "Dumps standalone hal.executable benchmarks to the provided path.";
+ let description = [{
+ Dumps one MLIR file per hal.executable containing the executable contents
+ and the host code required to dispatch them with fake buffers and operands.
+ These benchmarks can be run with the `iree-benchmark-module` tool to
+ microbenchmark individual dispatches outside of the whole program context.
+
+ The pass can only be run after executable translation but before host code
+ conversion as the original stream dialect ops are required to synthesize
+ the benchmarks.
+
+ There are many caveats with this approach and it will fail to generate
+ benchmarks in many cases such as dynamic shapes, dynamic operands, or
+ stateful data dependencies. Users should always prefer to build dedicated
+ benchmarks in their origin framework that can be guaranteed to match their
+ expectations and use appropriate test data. For example some dispatches may
+ produce NaNs or out-of-bounds accesses with the fake data generated by this
+ pass and either crash or result in unrepresentative performance.
+
+ In other words: don't blindly expect this pass to do anything but act as a
+ starting point for microbenchmarking. Verify the outputs, the benchmarking
+ methodology for the particular dispatch, and prepare to do more work. Or
+ just author proper benchmarks in the original framework!
+ }];
+ let options = [
+ Option<
+ "path", "path",
+ "std::string", "",
+ "File system path to write each executable benchmark MLIR file."
+ >,
+ ];
+ let dependentDialects = [
+ "mlir::arith::ArithDialect",
+ "mlir::func::FuncDialect",
+ "mlir::scf::SCFDialect",
+ "IREE::HAL::HALDialect",
+ "IREE::Util::UtilDialect",
+ ];
+}
+
+def StripExecutableContentsPass :
+ Pass<"iree-hal-strip-executable-contents", "mlir::ModuleOp"> {
+ let summary = "Strips executable module contents for reducing IR size during debugging.";
+ let description = [{
+ A debugging pass for stripping translated executable contents (LLVM dialect,
+ SPIR-V dialect, etc) to reduce IR size and noise from the device-only code.
+ }];
+}
+
+def RepeatDispatchesPass :
+ Pass<"iree-hal-repeat-dispatches", ""> {
+ let summary = "Repeats each hal.command_buffer.dispatch op one or more times.";
+ let description = [{
+ Finds all hal.command_buffer.dispatch ops and repeats them the specified
+ number of times by cloning them and inserting a barrier. This is extremely
+ unreliable and nearly always creates incorrect programs that have wildly
+ incorrect end-to-end execution timings. It must only be used when trying to
+ profile (via sampling or performance counters) specific dispatches in-situ
+ with the additional caveat that cache behavior and dispatch overhead are
+ invalid. Do not trust any numbers produced by this method of benchmarking
+ without verifying via external tooling.
+
+ This should rarely be used. Prefer instead to build real benchmarks in
+ origin frameworks that, for example, use independent data and ensure correct
+ execution results (as if you're benchmarking known-incorrect results, are
+ you really benchmarking something useful?). Any benchmarking of memory-bound
+ operations using this approach will be questionable (such as matmuls, which
+ we use this for today... heh ;).
+ }];
+ let options = [
+ Option<
+ "repeatCount", "count",
+ "unsigned", "1",
+ "Number of times to repeat each dispatch (including the original)."
+ >,
+ ];
+ let dependentDialects = [
+ "IREE::HAL::HALDialect",
+ ];
+}
+
+#endif // IREE_DIALECT_HAL_PASSES
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/PreprocessExecutables.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/PreprocessExecutables.cpp
index b668c25..b1c96ba 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/PreprocessExecutables.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/PreprocessExecutables.cpp
@@ -27,6 +27,12 @@
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_PREPROCESSEXECUTABLESWITHPIPELINEPASS
+#define GEN_PASS_DEF_PREPROCESSEXECUTABLESWITHTOOLPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
static StringRef fixupArg(StringRef arg) {
// HACK: pass pipeline parsing doesn't handle strings with spaces and the only
// way to get them through (I could find) is to double quote them. This
@@ -212,20 +218,16 @@
return success();
}
-class PreprocessExecutablesPass
- : public PassWrapper<PreprocessExecutablesPass,
- OperationPass<IREE::HAL::ExecutableOp>> {
-public:
- PreprocessExecutablesPass() = default;
- PreprocessExecutablesPass(const PreprocessExecutablesPass &pass) {}
- PreprocessExecutablesPass(std::optional<std::string> pipeline,
- std::optional<std::string> command) {
- if (pipeline.has_value()) {
- this->pipeline = std::move(pipeline).value();
- } else if (command.has_value()) {
- this->command = std::move(command).value();
- }
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-preprocess-executables-with-pipeline
+//===----------------------------------------------------------------------===//
+
+struct PreprocessExecutablesWithPipelinePass
+ : public IREE::HAL::impl::PreprocessExecutablesWithPipelinePassBase<
+ PreprocessExecutablesWithPipelinePass> {
+ using IREE::HAL::impl::PreprocessExecutablesWithPipelinePassBase<
+ PreprocessExecutablesWithPipelinePass>::
+ PreprocessExecutablesWithPipelinePassBase;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<IREE::HAL::HALDialect>();
@@ -239,79 +241,56 @@
}
}
- StringRef getArgument() const override {
- return "iree-hal-preprocess-executables";
- }
-
- StringRef getDescription() const override {
- return "Preprocesses each executable with a pass pipeline or external "
- "tool.";
- }
-
void runOnOperation() override {
+ if (!pipeline.hasValue())
+ return;
auto executableOp = getOperation();
- if (pipeline.hasValue()) {
- OpPassManager passManager(executableOp.getOperationName());
- if (failed(buildPassPipeline(pipeline, passManager))) {
- llvm::errs() << "ERROR: failed to parse preprocessing pipeline `"
- << pipeline << "`\n";
- return signalPassFailure();
- }
- if (failed(runPipeline(passManager, executableOp))) {
- llvm::errs() << "ERROR: failed to preprocess executable `"
- << executableOp.getName() << "` using pipeline `"
- << pipeline << "`\n";
- return signalPassFailure();
- }
- } else if (command.hasValue()) {
- if (failed(preprocessWithCommand(executableOp, command))) {
- llvm::errs() << "ERROR: failed to preprocess executable `"
- << executableOp.getName() << "` using command `" << command
- << "`\n";
- return signalPassFailure();
- }
+ OpPassManager passManager(executableOp.getOperationName());
+ if (failed(buildPassPipeline(pipeline, passManager))) {
+ llvm::errs() << "ERROR: failed to parse preprocessing pipeline `"
+ << pipeline << "`\n";
+ return signalPassFailure();
+ }
+ if (failed(runPipeline(passManager, executableOp))) {
+ llvm::errs() << "ERROR: failed to preprocess executable `"
+ << executableOp.getName() << "` using pipeline `" << pipeline
+ << "`\n";
+ return signalPassFailure();
}
}
-
-private:
- Option<std::string> pipeline{
- *this,
- "pipeline",
- llvm::cl::desc("Pass pipeline used to preprocess the executable."),
- llvm::cl::init(""),
- };
- Option<std::string> command{
- *this,
- "command",
- llvm::cl::desc("Shell command used to preprocess the executable."),
- llvm::cl::init(""),
- };
};
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createPreprocessExecutablesPass(std::string rawCommand) {
+//===----------------------------------------------------------------------===//
+// --iree-hal-preprocess-executables-with-tool
+//===----------------------------------------------------------------------===//
+
+struct PreprocessExecutablesWithToolPass
+ : public IREE::HAL::impl::PreprocessExecutablesWithToolPassBase<
+ PreprocessExecutablesWithToolPass> {
+ using IREE::HAL::impl::PreprocessExecutablesWithToolPassBase<
+ PreprocessExecutablesWithToolPass>::PreprocessExecutablesWithToolPassBase;
+ void runOnOperation() override {
+ if (!command.hasValue())
+ return;
+ auto executableOp = getOperation();
+ if (failed(preprocessWithCommand(executableOp, command))) {
+ llvm::errs() << "ERROR: failed to preprocess executable `"
+ << executableOp.getName() << "` using command `" << command
+ << "`\n";
+ return signalPassFailure();
+ }
+ }
+};
+
+} // namespace
+
+std::unique_ptr<Pass> createPreprocessExecutablesPass(std::string rawCommand) {
auto command = fixupArg(rawCommand);
if (command.starts_with("builtin.module")) {
- return createPreprocessExecutablesWithPipelinePass(command.str());
+ return createPreprocessExecutablesWithPipelinePass({command.str()});
} else {
- return createPreprocessExecutablesWithToolPass(command.str());
+ return createPreprocessExecutablesWithToolPass({command.str()});
}
}
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createPreprocessExecutablesWithPipelinePass(std::string pipeline) {
- return std::make_unique<PreprocessExecutablesPass>(std::move(pipeline),
- std::nullopt);
-}
-
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createPreprocessExecutablesWithToolPass(std::string command) {
- return std::make_unique<PreprocessExecutablesPass>(std::nullopt,
- std::move(command));
-}
-
-static PassRegistration<PreprocessExecutablesPass> pass([] {
- return std::make_unique<PreprocessExecutablesPass>();
-});
-
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/RepeatDispatches.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/RepeatDispatches.cpp
new file mode 100644
index 0000000..d7ee923
--- /dev/null
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/RepeatDispatches.cpp
@@ -0,0 +1,58 @@
+// Copyright 2021 The IREE Authors
+//
+// Licensed 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 "iree/compiler/Dialect/HAL/IR/HALDialect.h"
+#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
+#include "iree/compiler/Dialect/HAL/IR/HALTypes.h"
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir::iree_compiler::IREE::HAL {
+
+#define GEN_PASS_DEF_REPEATDISPATCHESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
+//===----------------------------------------------------------------------===//
+// --iree-hal-repeat-dispatches
+//===----------------------------------------------------------------------===//
+
+struct RepeatDispatchesPass
+ : public IREE::HAL::impl::RepeatDispatchesPassBase<RepeatDispatchesPass> {
+ using IREE::HAL::impl::RepeatDispatchesPassBase<
+ RepeatDispatchesPass>::RepeatDispatchesPassBase;
+ void runOnOperation() override {
+ // Collect all (nested) command buffer dispatch ops.
+ SmallVector<IREE::HAL::CommandBufferDispatchOp> ops;
+ getOperation()->walk(
+ [&ops](IREE::HAL::CommandBufferDispatchOp op) { ops.push_back(op); });
+ for (auto op : ops) {
+ OpBuilder builder(op);
+ for (unsigned i = 1; i < repeatCount; ++i) {
+ // Clone the op at its original location in the IR.
+ builder.clone(*op.getOperation());
+ // Add a barrier after each clone. If the original dispatch has a small
+ // problem size, simply duplicating without barrier will increase the
+ // number of subgroups and thus "help" filling the GPU. In the end we
+ // will have an over optimistic result. Inserting barriers avoids that,
+ // but it assumes that the command buffer has a linear dispatch
+ // structure.
+ builder.create<IREE::HAL::CommandBufferExecutionBarrierOp>(
+ op.getLoc(), op.getCommandBuffer(),
+ IREE::HAL::ExecutionStageBitfield::CommandRetire |
+ IREE::HAL::ExecutionStageBitfield::Dispatch,
+ IREE::HAL::ExecutionStageBitfield::CommandIssue |
+ IREE::HAL::ExecutionStageBitfield::Dispatch,
+ IREE::HAL::ExecutionBarrierFlagBitfield::None);
+ }
+ }
+ }
+};
+
+} // namespace
+
+} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/ResolveExportOrdinals.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/ResolveExportOrdinals.cpp
index c96819a..7d30bb1 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/ResolveExportOrdinals.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/ResolveExportOrdinals.cpp
@@ -4,6 +4,7 @@
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#include "iree/compiler/Dialect/HAL/IR/HALDialect.h"
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
#include "mlir/Pass/Pass.h"
@@ -11,9 +12,13 @@
namespace mlir::iree_compiler::IREE::HAL {
-class ResolveCommandBufferDispatchOrdinals
+#define GEN_PASS_DEF_RESOLVEEXPORTORDINALSPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
+struct ResolveCommandBufferDispatchOrdinals
: public OpRewritePattern<IREE::HAL::CommandBufferDispatchSymbolOp> {
-public:
using OpRewritePattern<
IREE::HAL::CommandBufferDispatchSymbolOp>::OpRewritePattern;
LogicalResult matchAndRewrite(IREE::HAL::CommandBufferDispatchSymbolOp op,
@@ -39,10 +44,9 @@
}
};
-class ResolveCommandBufferDispatchIndirectOrdinals
+struct ResolveCommandBufferDispatchIndirectOrdinals
: public OpRewritePattern<
IREE::HAL::CommandBufferDispatchIndirectSymbolOp> {
-public:
using OpRewritePattern<
IREE::HAL::CommandBufferDispatchIndirectSymbolOp>::OpRewritePattern;
LogicalResult
@@ -69,17 +73,13 @@
}
};
-class ResolveExportOrdinalsPass
- : public PassWrapper<ResolveExportOrdinalsPass, OperationPass<ModuleOp>> {
-public:
- StringRef getArgument() const override {
- return "iree-hal-resolve-export-ordinals";
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-resolve-export-ordinals
+//===----------------------------------------------------------------------===//
- StringRef getDescription() const override {
- return "Resolves hal.executable.export references to ordinals";
- }
-
+struct ResolveExportOrdinalsPass
+ : public IREE::HAL::impl::ResolveExportOrdinalsPassBase<
+ ResolveExportOrdinalsPass> {
void runOnOperation() override {
MLIRContext *context = &getContext();
RewritePatternSet patterns(&getContext());
@@ -92,10 +92,6 @@
}
};
-std::unique_ptr<OperationPass<ModuleOp>> createResolveExportOrdinalsPass() {
- return std::make_unique<ResolveExportOrdinalsPass>();
-}
-
-static PassRegistration<ResolveExportOrdinalsPass> pass;
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/SerializeExecutables.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/SerializeExecutables.cpp
index 4b2b5c2..99a7df0 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/SerializeExecutables.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/SerializeExecutables.cpp
@@ -11,6 +11,8 @@
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Target/TargetBackend.h"
#include "iree/compiler/Dialect/HAL/Target/TargetRegistry.h"
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
+#include "iree/compiler/Utils/TracingUtils.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/Support/FileSystem.h"
#include "mlir/IR/Attributes.h"
@@ -21,36 +23,25 @@
namespace mlir::iree_compiler::IREE::HAL {
-class SerializeTargetExecutablesPass
- : public PassWrapper<SerializeTargetExecutablesPass,
- OperationPass<IREE::HAL::ExecutableOp>> {
-public:
- SerializeTargetExecutablesPass()
- : targetRegistry(TargetBackendRegistry::getGlobal()) {}
- SerializeTargetExecutablesPass(const SerializeTargetExecutablesPass &pass)
- : targetRegistry(pass.targetRegistry) {}
- SerializeTargetExecutablesPass(const TargetBackendRegistry &targetRegistry,
- StringRef target, int debugLevel,
- std::string dumpIntermediatesPath,
- std::string dumpBinariesPath)
- : targetRegistry(targetRegistry) {
- this->target = target.str();
- this->debugLevel = debugLevel;
- this->dumpIntermediatesPath = dumpIntermediatesPath;
- this->dumpBinariesPath = dumpBinariesPath;
- }
+#define GEN_PASS_DEF_SERIALIZEEXECUTABLESPASS
+#define GEN_PASS_DEF_SERIALIZETARGETEXECUTABLESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
- StringRef getArgument() const override {
- return "iree-hal-serialize-target-executables";
- }
+namespace {
- StringRef getDescription() const override {
- return "Serializes hal.executable.variant ops to hal.executable.binary ops";
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-serialize-target-executables
+//===----------------------------------------------------------------------===//
+
+struct SerializeTargetExecutablesPass
+ : public IREE::HAL::impl::SerializeTargetExecutablesPassBase<
+ SerializeTargetExecutablesPass> {
+ using IREE::HAL::impl::SerializeTargetExecutablesPassBase<
+ SerializeTargetExecutablesPass>::SerializeTargetExecutablesPassBase;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<IREE::HAL::HALDialect>();
- auto targetBackend = targetRegistry.getTargetBackend(target);
+ auto targetBackend = targetRegistry->getTargetBackend(target);
if (targetBackend) {
targetBackend->getDependentDialects(registry);
}
@@ -60,7 +51,7 @@
auto executableOp = getOperation();
auto moduleOp = executableOp->getParentOfType<mlir::ModuleOp>();
- auto targetBackend = targetRegistry.getTargetBackend(target);
+ auto targetBackend = targetRegistry->getTargetBackend(target);
if (!targetBackend) {
executableOp.emitError()
<< "unregistered target backend '" << target << "'";
@@ -102,96 +93,35 @@
variantOp.erase();
}
}
-
-private:
- Option<std::string> target{
- *this, "target",
- llvm::cl::desc(
- "Target backend name whose executables will be serialized by "
- "this pass.")};
-
- Option<int> debugLevel{*this, "debug-level",
- llvm::cl::desc("Debug level for serialization (0-3)"),
- llvm::cl::init(2)};
- Option<std::string> dumpIntermediatesPath{
- *this, "dump-intermediates-path",
- llvm::cl::desc("Path to write translated executable intermediates (.bc, "
- ".o, etc) into for debugging.")};
- Option<std::string> dumpBinariesPath{
- *this, "dump-binaries-path",
- llvm::cl::desc("Path to write translated and serialized executable "
- "binaries into for debugging.")};
-
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createSerializeTargetExecutablesPass(
- const TargetBackendRegistry &targetRegistry, StringRef target,
- int debugLevel, std::string dumpIntermediatesPath,
- std::string dumpBinariesPath) {
- return std::make_unique<SerializeTargetExecutablesPass>(
- targetRegistry, target, debugLevel, dumpIntermediatesPath,
- dumpBinariesPath);
-}
+//===----------------------------------------------------------------------===//
+// --iree-hal-serialize-executables
+//===----------------------------------------------------------------------===//
-static PassRegistration<SerializeTargetExecutablesPass> linkTargetPass([] {
- return std::make_unique<SerializeTargetExecutablesPass>();
-});
-
-class SerializeExecutablesPass
- : public PassWrapper<SerializeExecutablesPass,
- OperationPass<IREE::HAL::ExecutableOp>> {
-public:
- SerializeExecutablesPass()
- : targetRegistry(TargetBackendRegistry::getGlobal()) {}
- SerializeExecutablesPass(const TargetBackendRegistry &targetRegistry,
- int debugLevel, std::string dumpIntermediatesPath,
- std::string dumpBinariesPath)
- : targetRegistry(targetRegistry), debugLevel(debugLevel),
- dumpIntermediatesPath(dumpIntermediatesPath),
- dumpBinariesPath(dumpBinariesPath) {}
-
- StringRef getArgument() const override {
- return "iree-hal-serialize-executables";
- }
-
- StringRef getDescription() const override {
- return "Serializes hal.executable.variant ops to hal.executable.binary ops";
- }
-
+struct SerializeExecutablesPass
+ : public IREE::HAL::impl::SerializeExecutablesPassBase<
+ SerializeExecutablesPass> {
+ using IREE::HAL::impl::SerializeExecutablesPassBase<
+ SerializeExecutablesPass>::SerializeExecutablesPassBase;
void runOnOperation() override {
auto executableOp = getOperation();
OpPassManager passManager(executableOp.getOperationName());
for (const auto &targetName : gatherExecutableTargetNames(executableOp)) {
- passManager.addPass(createSerializeTargetExecutablesPass(
- targetRegistry, targetName, debugLevel, dumpIntermediatesPath,
- dumpBinariesPath));
+ passManager.addPass(IREE::HAL::createSerializeTargetExecutablesPass(
+ {targetRegistry, targetName, debugLevel, dumpIntermediatesPath,
+ dumpBinariesPath}));
}
+
+ IREE_COMPILER_TRACE_MESSAGE_DYNAMIC(INFO, executableOp.getSymName().str());
+
if (failed(runPipeline(passManager, executableOp))) {
executableOp.emitError() << "failed to serialize executables";
return signalPassFailure();
}
}
-
-private:
- const TargetBackendRegistry &targetRegistry;
- int debugLevel;
- std::string dumpIntermediatesPath;
- std::string dumpBinariesPath;
};
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createSerializeExecutablesPass(const TargetBackendRegistry &targetRegistry,
- int debugLevel,
- std::string dumpIntermediatesPath,
- std::string dumpBinariesPath) {
- return std::make_unique<SerializeExecutablesPass>(
- targetRegistry, debugLevel, dumpIntermediatesPath, dumpBinariesPath);
-}
-
-static PassRegistration<SerializeExecutablesPass> linkPass([] {
- return std::make_unique<SerializeExecutablesPass>();
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/StripExecutableContents.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/StripExecutableContents.cpp
index a4d8600..bb52756 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/StripExecutableContents.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/StripExecutableContents.cpp
@@ -14,18 +14,18 @@
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_STRIPEXECUTABLECONTENTSPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
+//===----------------------------------------------------------------------===//
+// --iree-hal-strip-executable-contents
+//===----------------------------------------------------------------------===//
+
struct StripExecutableContentsPass
- : public PassWrapper<StripExecutableContentsPass,
- OperationPass<mlir::ModuleOp>> {
- StringRef getArgument() const override {
- return "iree-hal-strip-executable-contents";
- }
-
- StringRef getDescription() const override {
- return "Strips executable module contents for reducing IR size during "
- "debugging.";
- }
-
+ : public IREE::HAL::impl::StripExecutableContentsPassBase<
+ StripExecutableContentsPass> {
void runOnOperation() override {
for (auto executableOp : getOperation().getOps<IREE::HAL::ExecutableOp>()) {
for (auto variantOp :
@@ -38,11 +38,6 @@
}
};
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createStripExecutableContentsPass() {
- return std::make_unique<StripExecutableContentsPass>();
-}
-
-static PassRegistration<StripExecutableContentsPass> pass;
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/SubstituteExecutables.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/SubstituteExecutables.cpp
index 2e695a6..1623a27 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/SubstituteExecutables.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/SubstituteExecutables.cpp
@@ -18,6 +18,11 @@
namespace mlir::iree_compiler::IREE::HAL {
+#define GEN_PASS_DEF_SUBSTITUTEEXECUTABLESPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
+
+namespace {
+
// Scans |searchPath| for all child files and appends them to |substitutions|.
// The file basename will be treated as an executable name and the path will be
// absolute such that no object path resolution occurs later on.
@@ -200,31 +205,15 @@
}
}
-class SubstituteExecutablesPass
- : public PassWrapper<SubstituteExecutablesPass, OperationPass<ModuleOp>> {
-public:
- SubstituteExecutablesPass() = default;
- SubstituteExecutablesPass(const SubstituteExecutablesPass &pass) {}
- SubstituteExecutablesPass(ArrayRef<std::string> substitutions) {
- this->substitutions = substitutions;
- }
- SubstituteExecutablesPass(std::string searchPath) {
- this->searchPath = std::move(searchPath);
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-substitute-executables
+//===----------------------------------------------------------------------===//
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<IREE::HAL::HALDialect>();
- }
-
- StringRef getArgument() const override {
- return "iree-hal-substitute-executables";
- }
-
- StringRef getDescription() const override {
- return "Substitutes hal.executable ops by parsing |substitutions| in "
- "`executable_name=file.xxx` strings.";
- }
-
+struct SubstituteExecutablesPass
+ : public IREE::HAL::impl::SubstituteExecutablesPassBase<
+ SubstituteExecutablesPass> {
+ using IREE::HAL::impl::SubstituteExecutablesPassBase<
+ SubstituteExecutablesPass>::SubstituteExecutablesPassBase;
void runOnOperation() override {
auto moduleOp = getOperation();
auto moduleName = moduleOp.getName().value_or("module");
@@ -282,29 +271,8 @@
}
}
}
-
-private:
- ListOption<std::string> substitutions{
- *this, "substitutions",
- llvm::cl::desc(
- "Substitution `executable_name=file.xxx` key-value pairs.")};
- Option<std::string> searchPath{
- *this, "search-path",
- llvm::cl::desc("Path to source executable substitutions from.")};
};
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createSubstituteExecutablesPass(ArrayRef<std::string> substitutions) {
- return std::make_unique<SubstituteExecutablesPass>(substitutions);
-}
-
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createSubstituteExecutablesPass(std::string searchPath) {
- return std::make_unique<SubstituteExecutablesPass>(std::move(searchPath));
-}
-
-static PassRegistration<SubstituteExecutablesPass> pass([] {
- return std::make_unique<SubstituteExecutablesPass>();
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/TranslateExecutables.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/TranslateExecutables.cpp
index 060468d..a215884 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/TranslateExecutables.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/TranslateExecutables.cpp
@@ -11,6 +11,7 @@
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
#include "iree/compiler/Dialect/HAL/Target/TargetBackend.h"
#include "iree/compiler/Dialect/HAL/Target/TargetRegistry.h"
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
#include "iree/compiler/Utils/TracingUtils.h"
#include "llvm/ADT/StringSet.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
@@ -22,33 +23,27 @@
namespace mlir::iree_compiler::IREE::HAL {
-class TranslateTargetExecutableVariantsPass
- : public PassWrapper<TranslateTargetExecutableVariantsPass,
- OperationPass<IREE::HAL::ExecutableVariantOp>> {
-public:
- TranslateTargetExecutableVariantsPass()
- : targetRegistry(TargetBackendRegistry::getGlobal()) {}
- TranslateTargetExecutableVariantsPass(
- const TranslateTargetExecutableVariantsPass &pass)
- : targetRegistry(pass.targetRegistry) {}
- TranslateTargetExecutableVariantsPass(
- const TargetBackendRegistry &targetRegistry, StringRef target)
- : targetRegistry(targetRegistry) {
- this->target = target.str();
- }
+#define GEN_PASS_DEF_TRANSLATEEXECUTABLESPASS
+#define GEN_PASS_DEF_TRANSLATETARGETEXECUTABLEVARIANTSPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
- StringRef getArgument() const override {
- return "iree-hal-translate-target-executable-variants";
- }
+namespace {
- StringRef getDescription() const override {
- return "Serializes hal.executable.variant ops to hal.executable.binary ops";
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-translate-target-executable-variants
+//===----------------------------------------------------------------------===//
+
+struct TranslateTargetExecutableVariantsPass
+ : public IREE::HAL::impl::TranslateTargetExecutableVariantsPassBase<
+ TranslateTargetExecutableVariantsPass> {
+ using IREE::HAL::impl::TranslateTargetExecutableVariantsPassBase<
+ TranslateTargetExecutableVariantsPass>::
+ TranslateTargetExecutableVariantsPassBase;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<IREE::HAL::HALDialect>();
registry.insert<bufferization::BufferizationDialect>();
- auto targetBackend = targetRegistry.getTargetBackend(target);
+ auto targetBackend = targetRegistry->getTargetBackend(target);
if (targetBackend) {
targetBackend->getDependentDialects(registry);
}
@@ -59,7 +54,7 @@
if (variantOp.getTarget().getBackend().getValue() != target)
return;
- auto targetBackend = targetRegistry.getTargetBackend(target);
+ auto targetBackend = targetRegistry->getTargetBackend(target);
if (!targetBackend) {
variantOp.emitError() << "unregistered target backend '" << target << "'";
return signalPassFailure();
@@ -74,51 +69,23 @@
return signalPassFailure();
}
}
-
-private:
- Option<std::string> target{
- *this, "target",
- llvm::cl::desc(
- "Target backend name whose executables will be translated by "
- "this pass.")};
-
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableVariantOp>>
-createTranslateTargetExecutableVariantsPass(
- const TargetBackendRegistry &targetRegistry, StringRef target) {
- return std::make_unique<TranslateTargetExecutableVariantsPass>(targetRegistry,
- target);
-}
+//===----------------------------------------------------------------------===//
+// --iree-hal-translate-executables
+//===----------------------------------------------------------------------===//
-static PassRegistration<TranslateTargetExecutableVariantsPass> linkTargetPass(
- [] { return std::make_unique<TranslateTargetExecutableVariantsPass>(); });
-
-class TranslateExecutablesPass
- : public PassWrapper<TranslateExecutablesPass,
- OperationPass<IREE::HAL::ExecutableOp>> {
-public:
- TranslateExecutablesPass()
- : targetRegistry(TargetBackendRegistry::getGlobal()) {}
- TranslateExecutablesPass(const TranslateExecutablesPass &pass)
- : targetRegistry(pass.targetRegistry) {}
- TranslateExecutablesPass(const TargetBackendRegistry &targetRegistry)
- : targetRegistry(targetRegistry) {}
-
- StringRef getArgument() const override {
- return "iree-hal-translate-executables";
- }
-
- StringRef getDescription() const override {
- return "Serializes hal.executable.variant ops to hal.executable.binary ops";
- }
+struct TranslateExecutablesPass
+ : public IREE::HAL::impl::TranslateExecutablesPassBase<
+ TranslateExecutablesPass> {
+ using IREE::HAL::impl::TranslateExecutablesPassBase<
+ TranslateExecutablesPass>::TranslateExecutablesPassBase;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<IREE::HAL::HALDialect>();
registry.insert<bufferization::BufferizationDialect>();
- auto targetBackends = targetRegistry.getTargetBackends(
- targetRegistry.getRegisteredTargetBackends());
+ auto targetBackends = targetRegistry->getTargetBackends(
+ targetRegistry->getRegisteredTargetBackends());
for (auto &targetBackend : targetBackends) {
targetBackend->getDependentDialects(registry);
}
@@ -129,28 +96,19 @@
OpPassManager passManager(executableOp.getOperationName());
for (const auto &targetName : gatherExecutableTargetNames(executableOp)) {
passManager.addNestedPass<IREE::HAL::ExecutableVariantOp>(
- createTranslateTargetExecutableVariantsPass(targetRegistry,
- targetName));
+ IREE::HAL::createTranslateTargetExecutableVariantsPass(
+ {targetRegistry, targetName}));
}
IREE_COMPILER_TRACE_MESSAGE_DYNAMIC(INFO, executableOp.getSymName().str());
if (failed(runPipeline(passManager, executableOp))) {
- executableOp.emitError() << "failed to serialize executables";
+ executableOp.emitError() << "failed to translate executables";
return signalPassFailure();
}
}
-
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<IREE::HAL::ExecutableOp>>
-createTranslateExecutablesPass(const TargetBackendRegistry &targetRegistry) {
- return std::make_unique<TranslateExecutablesPass>(targetRegistry);
-}
-
-static PassRegistration<TranslateExecutablesPass> translatePass([] {
- return std::make_unique<TranslateExecutablesPass>();
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/VerifyTargetEnvironment.cpp b/compiler/src/iree/compiler/Dialect/HAL/Transforms/VerifyTargetEnvironment.cpp
index 39f378b..64a003d 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/VerifyTargetEnvironment.cpp
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/VerifyTargetEnvironment.cpp
@@ -12,7 +12,6 @@
#include "iree/compiler/Dialect/HAL/Target/TargetBackend.h"
#include "iree/compiler/Dialect/HAL/Target/TargetRegistry.h"
#include "iree/compiler/Dialect/HAL/Transforms/Passes.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Attributes.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinTypes.h"
@@ -21,24 +20,20 @@
namespace mlir::iree_compiler::IREE::HAL {
-class VerifyTargetEnvironmentPass
- : public PassWrapper<VerifyTargetEnvironmentPass, OperationPass<ModuleOp>> {
-public:
- VerifyTargetEnvironmentPass(const TargetBackendRegistry &targetRegistry)
- : targetRegistry(targetRegistry) {}
+#define GEN_PASS_DEF_VERIFYTARGETENVIRONMENTPASS
+#include "iree/compiler/Dialect/HAL/Transforms/Passes.h.inc"
- void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<IREE::HAL::HALDialect>();
- }
+namespace {
- StringRef getArgument() const override {
- return "iree-hal-verify-target-environment";
- }
+//===----------------------------------------------------------------------===//
+// --iree-hal-verify-target-environment
+//===----------------------------------------------------------------------===//
- StringRef getDescription() const override {
- return "Verifies that the target execution environment is valid.";
- }
-
+struct VerifyTargetEnvironmentPass
+ : public IREE::HAL::impl::VerifyTargetEnvironmentPassBase<
+ VerifyTargetEnvironmentPass> {
+ using IREE::HAL::impl::VerifyTargetEnvironmentPassBase<
+ VerifyTargetEnvironmentPass>::VerifyTargetEnvironmentPassBase;
void runOnOperation() override {
auto moduleOp = getOperation();
@@ -64,7 +59,7 @@
diagnostic
<< "no HAL target devices specified on the module (available = [ ";
for (const auto &targetName :
- targetRegistry.getRegisteredTargetBackends()) {
+ targetRegistry->getRegisteredTargetBackends()) {
diagnostic << "'" << targetName << "' ";
}
diagnostic << "])";
@@ -82,14 +77,14 @@
}
auto targetBackend =
- targetRegistry.getTargetBackend(targetAttr.getDeviceID().getValue());
+ targetRegistry->getTargetBackend(targetAttr.getDeviceID().getValue());
if (!targetBackend) {
auto diagnostic = moduleOp.emitError();
diagnostic
<< "unregistered target backend " << targetAttr.getDeviceID()
<< "; ensure it is linked in to the compiler (available = [ ";
for (const auto &targetName :
- targetRegistry.getRegisteredTargetBackends()) {
+ targetRegistry->getRegisteredTargetBackends()) {
diagnostic << "'" << targetName << "' ";
}
diagnostic << "])";
@@ -98,18 +93,8 @@
}
}
}
-
- const TargetBackendRegistry &targetRegistry;
};
-std::unique_ptr<OperationPass<ModuleOp>>
-createVerifyTargetEnvironmentPass(const TargetBackendRegistry &targetRegistry) {
- return std::make_unique<VerifyTargetEnvironmentPass>(targetRegistry);
-}
-
-static PassRegistration<VerifyTargetEnvironmentPass> pass([] {
- return std::make_unique<VerifyTargetEnvironmentPass>(
- TargetBackendRegistry::getGlobal());
-});
+} // namespace
} // namespace mlir::iree_compiler::IREE::HAL
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/BUILD.bazel b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/BUILD.bazel
index 778254c..3c930d0 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/BUILD.bazel
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/BUILD.bazel
@@ -17,7 +17,6 @@
srcs = enforce_glob(
[
"assign_target_devices.mlir",
- "benchmark_batch_dispatches.mlir",
"convert_to_hal.mlir",
"dump_executable_benchmarks.mlir",
"dump_executable_sources.mlir",
@@ -28,6 +27,7 @@
"materialize_resource_caches.mlir",
"memoize_device_queries.mlir",
"preprocess_executables.mlir",
+ "repeat_dispatches.mlir",
"resolve_export_ordinals.mlir",
"strip_executable_contents.mlir",
"substitute_executables.mlir",
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/CMakeLists.txt b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/CMakeLists.txt
index 2f5b0e9..b4be816 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/CMakeLists.txt
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/CMakeLists.txt
@@ -15,7 +15,6 @@
lit
SRCS
"assign_target_devices.mlir"
- "benchmark_batch_dispatches.mlir"
"convert_to_hal.mlir"
"dump_executable_benchmarks.mlir"
"dump_executable_sources.mlir"
@@ -26,6 +25,7 @@
"materialize_resource_caches.mlir"
"memoize_device_queries.mlir"
"preprocess_executables.mlir"
+ "repeat_dispatches.mlir"
"resolve_export_ordinals.mlir"
"strip_executable_contents.mlir"
"substitute_executables.mlir"
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/materialize_dispatch_instrumentation.mlir b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/materialize_dispatch_instrumentation.mlir
index 3ea7bf2..fcb1a75 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/materialize_dispatch_instrumentation.mlir
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/materialize_dispatch_instrumentation.mlir
@@ -1,4 +1,4 @@
-// RUN: iree-opt --split-input-file --pass-pipeline='builtin.module(iree-hal-materialize-dispatch-instrumentation{bufferSize=64mib})' %s | FileCheck %s
+// RUN: iree-opt --split-input-file --pass-pipeline='builtin.module(iree-hal-materialize-dispatch-instrumentation{buffer-size=64mib})' %s | FileCheck %s
module attributes {hal.device.targets = [
#hal.device.target<"llvm-cpu", {
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/preprocess_executables.mlir b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/preprocess_executables.mlir
index 670a326..6742b24 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/preprocess_executables.mlir
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/preprocess_executables.mlir
@@ -1,9 +1,9 @@
// RUN: iree-opt --split-input-file %s \
-// RUN: --pass-pipeline="builtin.module(hal.executable(iree-hal-preprocess-executables{pipeline=\"builtin.module(iree-codegen-test-executable-preprocessing)\"}))" | \
+// RUN: --pass-pipeline="builtin.module(hal.executable(iree-hal-preprocess-executables-with-pipeline{pipeline=\"builtin.module(iree-codegen-test-executable-preprocessing)\"}))" | \
// RUN: FileCheck %s
// RUN: iree-opt --split-input-file %s \
-// RUN: --pass-pipeline="builtin.module(hal.executable(iree-hal-preprocess-executables{command=\"iree-opt --iree-codegen-test-executable-preprocessing\"}))" | \
+// RUN: --pass-pipeline="builtin.module(hal.executable(iree-hal-preprocess-executables-with-tool{command=\"iree-opt --iree-codegen-test-executable-preprocessing\"}))" | \
// RUN: FileCheck %s
// Uses a test pass to simulate an external user pipeline or tool that
diff --git a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/benchmark_batch_dispatches.mlir b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/repeat_dispatches.mlir
similarity index 96%
rename from compiler/src/iree/compiler/Dialect/HAL/Transforms/test/benchmark_batch_dispatches.mlir
rename to compiler/src/iree/compiler/Dialect/HAL/Transforms/test/repeat_dispatches.mlir
index 54fe8b1..7e60dbc 100644
--- a/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/benchmark_batch_dispatches.mlir
+++ b/compiler/src/iree/compiler/Dialect/HAL/Transforms/test/repeat_dispatches.mlir
@@ -1,4 +1,4 @@
-// RUN: iree-opt --split-input-file -test-iree-hal-benchmark-batch-dispatches-2-times %s | FileCheck %s
+// RUN: iree-opt --split-input-file --pass-pipeline='builtin.module(func.func(iree-hal-repeat-dispatches{count=2}))' %s | FileCheck %s
util.global @_executable : !hal.executable
diff --git a/compiler/src/iree/compiler/Dialect/Stream/Transforms/BUILD.bazel b/compiler/src/iree/compiler/Dialect/Stream/Transforms/BUILD.bazel
index 1c96994..278e82e 100644
--- a/compiler/src/iree/compiler/Dialect/Stream/Transforms/BUILD.bazel
+++ b/compiler/src/iree/compiler/Dialect/Stream/Transforms/BUILD.bazel
@@ -30,6 +30,7 @@
"PackConstants.cpp",
"PackDispatchOperands.cpp",
"Passes.cpp",
+ "Passes.h.inc",
"PropagateTimepoints.cpp",
"RefineUsage.cpp",
"ScheduleAllocation.cpp",
@@ -41,12 +42,10 @@
],
hdrs = [
"Passes.h",
- "Passes.h.inc",
],
deps = [
":PassesIncGen",
"//compiler/src/iree/compiler/Dialect/Flow/IR",
- "//compiler/src/iree/compiler/Dialect/Flow/Transforms",
"//compiler/src/iree/compiler/Dialect/HAL/IR",
"//compiler/src/iree/compiler/Dialect/Stream/Analysis",
"//compiler/src/iree/compiler/Dialect/Stream/Builtins",
diff --git a/compiler/src/iree/compiler/Dialect/Stream/Transforms/CMakeLists.txt b/compiler/src/iree/compiler/Dialect/Stream/Transforms/CMakeLists.txt
index c6c2d51..34ea128 100644
--- a/compiler/src/iree/compiler/Dialect/Stream/Transforms/CMakeLists.txt
+++ b/compiler/src/iree/compiler/Dialect/Stream/Transforms/CMakeLists.txt
@@ -15,7 +15,6 @@
Transforms
HDRS
"Passes.h"
- "Passes.h.inc"
SRCS
"AnnotateDispatchArguments.cpp"
"ConvertToStream.cpp"
@@ -32,6 +31,7 @@
"PackConstants.cpp"
"PackDispatchOperands.cpp"
"Passes.cpp"
+ "Passes.h.inc"
"PropagateTimepoints.cpp"
"RefineUsage.cpp"
"ScheduleAllocation.cpp"
@@ -62,7 +62,6 @@
MLIRTransforms
MLIRVectorDialect
iree::compiler::Dialect::Flow::IR
- iree::compiler::Dialect::Flow::Transforms
iree::compiler::Dialect::HAL::IR
iree::compiler::Dialect::Stream::Analysis
iree::compiler::Dialect::Stream::Builtins
diff --git a/compiler/src/iree/compiler/Dialect/Stream/Transforms/Passes.cpp b/compiler/src/iree/compiler/Dialect/Stream/Transforms/Passes.cpp
index a9a4856..aa1a2d6 100644
--- a/compiler/src/iree/compiler/Dialect/Stream/Transforms/Passes.cpp
+++ b/compiler/src/iree/compiler/Dialect/Stream/Transforms/Passes.cpp
@@ -8,7 +8,6 @@
#include <memory>
-#include "iree/compiler/Dialect/Flow/Transforms/Passes.h"
#include "iree/compiler/Dialect/Util/Transforms/Passes.h"
#include "iree/compiler/Utils/PassUtils.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
@@ -47,7 +46,7 @@
}
//===----------------------------------------------------------------------===//
-// -iree-stream-tensor-transformation-pipeline
+// --iree-stream-tensor-transformation-pipeline
//===----------------------------------------------------------------------===//
void buildStreamTensorPassPipeline(OpPassManager &passManager,
@@ -106,7 +105,7 @@
}
//===----------------------------------------------------------------------===//
-// -iree-stream-async-transformation-pipeline
+// --iree-stream-async-transformation-pipeline
//===----------------------------------------------------------------------===//
void buildStreamAsyncPassPipeline(OpPassManager &passManager,
@@ -181,7 +180,7 @@
}
//===----------------------------------------------------------------------===//
-// -iree-stream-cmd-transformation-pipeline
+// --iree-stream-cmd-transformation-pipeline
//===----------------------------------------------------------------------===//
void buildStreamCmdPassPipeline(OpPassManager &passManager,
@@ -220,7 +219,7 @@
}
//===----------------------------------------------------------------------===//
-// -iree-stream-optimization-pipeline
+// --iree-stream-optimization-pipeline
//===----------------------------------------------------------------------===//
void buildStreamOptimizationPassPipeline(
@@ -304,7 +303,7 @@
}
//===----------------------------------------------------------------------===//
-// -iree-stream-transformation-pipeline
+// --iree-stream-transformation-pipeline
//===----------------------------------------------------------------------===//
void buildStreamTransformPassPipeline(
@@ -350,7 +349,16 @@
// Registration
//===----------------------------------------------------------------------===//
-void registerStreamTransformPassPipelines() {
+namespace {
+#define GEN_PASS_REGISTRATION
+#include "iree/compiler/Dialect/Stream/Transforms/Passes.h.inc" // IWYU pragma: export
+} // namespace
+
+void registerStreamPasses() {
+ // Generated.
+ registerPasses();
+
+ // Pipelines.
PassPipelineRegistration<TransformOptions> tensorPassPipeline(
"iree-stream-tensor-transformation-pipeline",
"Lowers source dialects into stream.tensor.* IR.",
@@ -384,17 +392,4 @@
});
}
-namespace {
-#define GEN_PASS_REGISTRATION
-#include "iree/compiler/Dialect/Stream/Transforms/Passes.h.inc" // IWYU pragma: export
-} // namespace
-
-void registerStreamPasses() {
- // Generated.
- registerPasses();
-
- // Pipelines.
- registerStreamTransformPassPipelines();
-}
-
} // namespace mlir::iree_compiler::IREE::Stream
diff --git a/compiler/src/iree/compiler/Dialect/Vulkan/Utils/test/multiple_target_env_conversion.mlir b/compiler/src/iree/compiler/Dialect/Vulkan/Utils/test/multiple_target_env_conversion.mlir
index 7c6cb29..e2e3e87 100644
--- a/compiler/src/iree/compiler/Dialect/Vulkan/Utils/test/multiple_target_env_conversion.mlir
+++ b/compiler/src/iree/compiler/Dialect/Vulkan/Utils/test/multiple_target_env_conversion.mlir
@@ -1,5 +1,4 @@
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' \
-// RUN: --iree-hal-target-backends=vulkan-spirv \
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' \
// RUN: --iree-vulkan-target-triple=rdna3-7900xtx-windows \
// RUN: --iree-vulkan-target-env="#vk.target_env<v1.1, r(120), [VK_KHR_spirv_1_4, VK_KHR_storage_buffer_storage_class], AMD:DiscreteGPU, #vk.caps<maxComputeSharedMemorySize = 16384, maxComputeWorkGroupInvocations = 1024, maxComputeWorkGroupSize = dense<[128, 8, 4]>: vector<3xi32>, subgroupFeatures = 63 : i32, subgroupSize = 4 >>" \
// RUN: --iree-vulkan-target-triple=valhall-unknown-android31 \
diff --git a/compiler/src/iree/compiler/Dialect/Vulkan/Utils/test/target_env_conversion.mlir b/compiler/src/iree/compiler/Dialect/Vulkan/Utils/test/target_env_conversion.mlir
index ae43012..62d531b 100644
--- a/compiler/src/iree/compiler/Dialect/Vulkan/Utils/test/target_env_conversion.mlir
+++ b/compiler/src/iree/compiler/Dialect/Vulkan/Utils/test/target_env_conversion.mlir
@@ -1,12 +1,12 @@
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv %s | FileCheck %s --check-prefix=DEFAULT
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv --iree-vulkan-target-triple=adreno-a650-android30 %s | FileCheck %s --check-prefix=ADRENO
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv --iree-vulkan-target-triple=valhall-unknown-android31 %s | FileCheck %s --check-prefix=VALHALL
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv --iree-vulkan-target-triple=turing-t4-linux %s | FileCheck %s --check-prefix=TURING
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv --iree-vulkan-target-triple=rdna1-5700xt-windows %s | FileCheck %s --check-prefix=RDNA1
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv --iree-vulkan-target-triple=rdna3-6900xtx-windows %s | FileCheck %s --check-prefix=RDNA3
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv --iree-vulkan-target-triple=m1-moltenvk-macos %s | FileCheck %s --check-prefix=M1
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv --iree-vulkan-target-triple=arc-770-windows %s | FileCheck %s --check-prefix=ARC
-// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-transformation-pipeline{serialize-executables=false})' --iree-hal-target-backends=vulkan-spirv --iree-vulkan-target-triple=pascal-1080-windows %s | FileCheck %s --check-prefix=PASCAL
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' %s | FileCheck %s --check-prefix=DEFAULT
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' --iree-vulkan-target-triple=adreno-a650-android30 %s | FileCheck %s --check-prefix=ADRENO
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' --iree-vulkan-target-triple=valhall-unknown-android31 %s | FileCheck %s --check-prefix=VALHALL
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' --iree-vulkan-target-triple=turing-t4-linux %s | FileCheck %s --check-prefix=TURING
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' --iree-vulkan-target-triple=rdna1-5700xt-windows %s | FileCheck %s --check-prefix=RDNA1
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' --iree-vulkan-target-triple=rdna3-6900xtx-windows %s | FileCheck %s --check-prefix=RDNA3
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' --iree-vulkan-target-triple=m1-moltenvk-macos %s | FileCheck %s --check-prefix=M1
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' --iree-vulkan-target-triple=arc-770-windows %s | FileCheck %s --check-prefix=ARC
+// RUN: iree-opt --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=vulkan-spirv},iree-hal-transformation-pipeline{serialize-executables=false})' --iree-vulkan-target-triple=pascal-1080-windows %s | FileCheck %s --check-prefix=PASCAL
// TODO(antiagainst): Passing in lenghty strings as command-line options is not
// optimal. We should consider creating a dedicated test pass to pick up
diff --git a/compiler/src/iree/compiler/Modules/HAL/Inline/Transforms/Passes.cpp b/compiler/src/iree/compiler/Modules/HAL/Inline/Transforms/Passes.cpp
index 0ad371a..7c02c39 100644
--- a/compiler/src/iree/compiler/Modules/HAL/Inline/Transforms/Passes.cpp
+++ b/compiler/src/iree/compiler/Modules/HAL/Inline/Transforms/Passes.cpp
@@ -61,9 +61,9 @@
// Translate each executable down to common MLIR dialects.
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
- IREE::HAL::createConfigureExecutablesPass(targetRegistry));
+ IREE::HAL::createConfigureExecutablesPass({targetRegistry}));
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
- IREE::HAL::createTranslateExecutablesPass(targetRegistry));
+ IREE::HAL::createTranslateExecutablesPass({targetRegistry}));
// Inline the translated executable functions.
// We preserve the executables for their metadata used during conversion.
diff --git a/compiler/src/iree/compiler/Modules/HAL/Loader/Transforms/Passes.cpp b/compiler/src/iree/compiler/Modules/HAL/Loader/Transforms/Passes.cpp
index b675e1d..9b58d42 100644
--- a/compiler/src/iree/compiler/Modules/HAL/Loader/Transforms/Passes.cpp
+++ b/compiler/src/iree/compiler/Modules/HAL/Loader/Transforms/Passes.cpp
@@ -66,9 +66,9 @@
// After this point the executables are opaque blobs and we cannot change
// their interfaces.
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
- IREE::HAL::createConfigureExecutablesPass(targetRegistry));
+ IREE::HAL::createConfigureExecutablesPass({targetRegistry}));
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
- IREE::HAL::createTranslateExecutablesPass(targetRegistry));
+ IREE::HAL::createTranslateExecutablesPass({targetRegistry}));
//----------------------------------------------------------------------------
// Conversion
@@ -82,7 +82,7 @@
//----------------------------------------------------------------------------
// Link executables together.
- passManager.addPass(IREE::HAL::createLinkExecutablesPass(targetRegistry));
+ passManager.addPass(IREE::HAL::createLinkExecutablesPass({targetRegistry}));
// Resolve export ordinals from nested symbol references prior to
// serialization.
@@ -91,9 +91,9 @@
// Serialize executables to their binary forms.
passManager.addNestedPass<IREE::HAL::ExecutableOp>(
IREE::HAL::createSerializeExecutablesPass(
- targetRegistry, targetOptions.debugLevel,
- targetOptions.executableIntermediatesPath,
- targetOptions.executableBinariesPath));
+ {&targetRegistry, targetOptions.debugLevel,
+ targetOptions.executableIntermediatesPath,
+ targetOptions.executableBinariesPath}));
// NOTE: symbol DCE will destroy executable target contents.
passManager.addPass(mlir::createSymbolDCEPass());
diff --git a/compiler/src/iree/compiler/Pipelines/Pipelines.cpp b/compiler/src/iree/compiler/Pipelines/Pipelines.cpp
index 40a5499..f8ebd27 100644
--- a/compiler/src/iree/compiler/Pipelines/Pipelines.cpp
+++ b/compiler/src/iree/compiler/Pipelines/Pipelines.cpp
@@ -37,7 +37,7 @@
// specifying targets.
if (!executableOptions.targets.empty()) {
passManager.addPass(IREE::HAL::createAssignTargetDevicesPass(
- targetRegistry, executableOptions.targets));
+ {&targetRegistry, executableOptions.targets}));
}
// Input pipelines can result in changes to the exported functions and types
diff --git a/compiler/src/iree/compiler/Utils/OptionUtils.cpp b/compiler/src/iree/compiler/Utils/OptionUtils.cpp
index 015bf26..e8d9491 100644
--- a/compiler/src/iree/compiler/Utils/OptionUtils.cpp
+++ b/compiler/src/iree/compiler/Utils/OptionUtils.cpp
@@ -122,12 +122,10 @@
return size * scale;
}
-namespace llvm {
-namespace cl {
+namespace llvm::cl {
template class basic_parser<ByteSize>;
template class basic_parser<PowerOf2ByteSize>;
-} // namespace cl
-} // namespace llvm
+} // namespace llvm::cl
using ByteSize = llvm::cl::ByteSize;
using PowerOf2ByteSize = llvm::cl::PowerOf2ByteSize;
diff --git a/compiler/src/iree/compiler/Utils/OptionUtils.h b/compiler/src/iree/compiler/Utils/OptionUtils.h
index f04f8c4..c2b5812 100644
--- a/compiler/src/iree/compiler/Utils/OptionUtils.h
+++ b/compiler/src/iree/compiler/Utils/OptionUtils.h
@@ -236,8 +236,7 @@
} // namespace mlir::iree_compiler
-namespace llvm {
-namespace cl {
+namespace llvm::cl {
struct ByteSize {
int64_t value = 0;
@@ -276,7 +275,6 @@
void anchor() override;
};
-} // namespace cl
-} // namespace llvm
+} // namespace llvm::cl
#endif // IREE_COMPILER_UTILS_FLAG_UTILS_H
diff --git a/tests/e2e/regression/libm_linking.mlir b/tests/e2e/regression/libm_linking.mlir
index d0b4afe..543ac86 100644
--- a/tests/e2e/regression/libm_linking.mlir
+++ b/tests/e2e/regression/libm_linking.mlir
@@ -1,5 +1,5 @@
-// RUN: iree-opt --split-input-file --iree-transformation-pipeline --iree-hal-target-backends=llvm-cpu %s | FileCheck %s
-// RUN: iree-opt --split-input-file --iree-transformation-pipeline --iree-hal-target-backends=llvm-cpu --iree-llvmcpu-link-embedded=false %s | FileCheck %s
+// RUN: iree-opt --split-input-file --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=llvm-cpu},iree-transformation-pipeline)' %s | FileCheck %s
+// RUN: iree-opt --split-input-file --pass-pipeline='builtin.module(iree-hal-assign-target-devices{targets=llvm-cpu},iree-transformation-pipeline)' --iree-llvmcpu-link-embedded=false %s | FileCheck %s
// When lowering to CPU code through LLVM, certain LLVM intrinsics require
// linking against libm (the standard C library of math functions, `-lm`).
diff --git a/tools/test/executable_configurations.mlir b/tools/test/executable_configurations.mlir
index 67ca926..98554fc 100644
--- a/tools/test/executable_configurations.mlir
+++ b/tools/test/executable_configurations.mlir
@@ -33,12 +33,12 @@
// for individual executables one or more `executable_name=file.mlir` pairs can
// be repeated in `--iree-hal-substitute-executable-configuration=`.
-func.func @abs(%input : tensor<f32>) -> (tensor<f32>) {
+func.func @abs(%input : tensor<f32>) -> tensor<f32> {
%result = math.absf %input : tensor<f32>
return %result : tensor<f32>
}
-// CHECK: IR Dump Before mlir::iree_compiler::IREE::HAL::SerializeExecutablesPass
+// CHECK: IR Dump Before SerializeExecutablesPass
// CHECK: hal.executable public @abs_dispatch_0
// CHECK: hal.executable.variant public @vmvx_bytecode_fb
// CHECK: vm.func private @abs_dispatch_0_generic
diff --git a/tools/test/executable_sources.mlir b/tools/test/executable_sources.mlir
index 92df2e9..30e305e 100644
--- a/tools/test/executable_sources.mlir
+++ b/tools/test/executable_sources.mlir
@@ -36,7 +36,7 @@
return %result : tensor<f32>
}
-// CHECK: IR Dump Before mlir::iree_compiler::IREE::HAL::SerializeExecutablesPass
+// CHECK: IR Dump Before SerializeExecutablesPass
// CHECK: hal.executable public @abs_dispatch_0
// CHECK: hal.executable.variant public @vmvx_bytecode_fb
// CHECK: vm.func private @abs_dispatch_0_generic
