Add dep-analysis pass (a.k.a. features/qubit-mgmt)

include/cudaq/Optimizer/CallGraphFix.h

@@ -0,0 +1,47 @@
+/****************************************************************-*- C++ -*-****
+ * Copyright (c) 2022 - 2024 NVIDIA Corporation & Affiliates.                  *
+ * All rights reserved.                                                        *
+ *                                                                             *
+ * This source code and the accompanying materials are made available under    *
+ * the terms of the Apache License 2.0 which accompanies this distribution.    *
+ ******************************************************************************/
+
+#pragma once
+
+#include "mlir/Analysis/CallGraph.h"
+
+namespace llvm {
+// FIXME: `GraphTraits` specialization for `const mlir::CallGraphNode *` in
+// "mlir/Analysis/CallGraph.h" has a bug.
+// In particular, `GraphTraits<const mlir::CallGraphNode *>` typedef'ed `NodeRef
+// -> mlir::CallGraphNode *`, (without `const`), causing problems when using
+// `mlir::CallGraphNode` with graph iterator (e.g., `llvm::df_iterator`). The
+// entry node getter has the signature `NodeRef getEntryNode(NodeRef node)`,
+// i.e., `mlir::CallGraphNode * getEntryNode(mlir::CallGraphNode * node)`; but a
+// graph iterator for `const mlir::CallGraphNode *` will pass a `const
+// mlir::CallGraphNode *` to that `getEntryNode` function => compile error.
+// Here, we define a non-const overload, which hasn't been defined, to work
+// around that issue.
+//
+// Note: this isn't an issue for the whole `mlir::CallGraph` graph, i.e.,
+// `GraphTraits<const mlir::CallGraph *>`. `getEntryNode` is defined as
+// `getExternalCallerNode`, which is a const method of `mlir::CallGraph`.
+
+template <>
+struct GraphTraits<mlir::CallGraphNode *> {
+  using NodeRef = mlir::CallGraphNode *;
+  static NodeRef getEntryNode(NodeRef node) { return node; }
+
+  static NodeRef unwrap(const mlir::CallGraphNode::Edge &edge) {
+    return edge.getTarget();
+  }
+  using ChildIteratorType =
+      mapped_iterator<mlir::CallGraphNode::iterator, decltype(&unwrap)>;
+  static ChildIteratorType child_begin(NodeRef node) {
+    return {node->begin(), &unwrap};
+  }
+  static ChildIteratorType child_end(NodeRef node) {
+    return {node->end(), &unwrap};
+  }
+};
+} // namespace llvm

include/cudaq/Optimizer/CodeGen/Passes.h

@@ -27,15 +27,19 @@ class LLVMStructType;
 } // namespace mlir
 
 namespace cudaq::opt {
-void registerConvertToQIRPass();
 
 /// Convert (generic) QIR to the profile-specific QIR for a specific target.
 /// @param pm Pass Manager to add QIR passes to
 /// @param convertTo Expected to be `qir-base` or `qir-adaptive` (comes from the
 /// cudaq-translate command line `--convert-to` parameter)
-void addQIRProfilePipeline(mlir::OpPassManager &pm, llvm::StringRef convertTo);
+/// @param performPrep Whether or not to perform the initial prep pass (normally
+/// true, but false for the WireSet QIR path)
+void addQIRProfilePipeline(mlir::OpPassManager &pm, llvm::StringRef convertTo,
+                           bool performPrep = true);
 
 void addLowerToCCPipeline(mlir::OpPassManager &pm);
+void addWiresetToProfileQIRPipeline(mlir::OpPassManager &pm,
+                                    llvm::StringRef profile);
 
 /// @brief Verify that all `CallOp` targets are QIR- or NVQIR-defined functions
 /// or in the provided allowed list.
@@ -45,7 +49,6 @@ createVerifyNVQIRCallOpsPass(const std::vector<llvm::StringRef> &allowedFuncs);
 // Use the addQIRProfilePipeline() for the following passes.
 std::unique_ptr<mlir::Pass>
 createQIRToQIRProfilePass(llvm::StringRef convertTo);
-std::unique_ptr<mlir::Pass> verifyQIRProfilePass(llvm::StringRef convertTo);
 std::unique_ptr<mlir::Pass> createQIRProfilePreparationPass();
 std::unique_ptr<mlir::Pass>
 createConvertToQIRFuncPass(llvm::StringRef convertTo);
@@ -59,6 +62,7 @@ void registerCodeGenDialect(mlir::DialectRegistry &registry);
 mlir::LLVM::LLVMStructType lambdaAsPairOfPointers(mlir::MLIRContext *context);
 
 void registerToExecutionManagerCCPipeline();
+void registerWireSetToProfileQIRPipeline();
 void populateCCTypeConversions(mlir::LLVMTypeConverter *converter);
 
 // declarative passes

include/cudaq/Optimizer/CodeGen/Passes.td

@@ -23,9 +23,7 @@ def QuakeToCC : Pass<"quake-to-cc", "mlir::ModuleOp"> {
     execution manager.
   }];
 
-  let dependentDialects = [
-    "cudaq::cc::CCDialect", "mlir::LLVM::LLVMDialect"
-  ];
+  let dependentDialects = ["cudaq::cc::CCDialect", "mlir::LLVM::LLVMDialect"];
 }
 
 def QuakeToCCPrep : Pass<"quake-to-cc-prep", "mlir::ModuleOp"> {
@@ -89,21 +87,6 @@ def QIRToQIRProfilePrep : Pass<"qir-profile-prep", "mlir::ModuleOp"> {
   let constructor = "cudaq::opt::createQIRProfilePreparationPass()";
 }
 
-def VerifyQIRProfile : Pass<"verify-qir-profile", "mlir::LLVM::LLVMFuncOp"> {
-  let summary = "Verify that the output conforms to the specific profile";
-  let description = [{
-    This pass scans over functions in the LLVM-IR dialect to make sure they
-    conform to the QIR specific profile.
-  }];
-
-  let options = [
-    Option<"convertTo", "convert-to", "std::string", "\"qir-base\"",
-           "Which QIR profile to convert to (default is 'qir-base')">
-  ];
-
-  let constructor = "cudaq::opt::verifyQIRProfilePass(\"qir-base\")";
-}
-
 def QIRToQIRProfileFunc : Pass<"quake-to-qir-func",
                             "mlir::LLVM::LLVMFuncOp"> {
   let summary = "Analyze kernels and add attributes and record calls.";
@@ -118,7 +101,7 @@ def QIRToQIRProfileFunc : Pass<"quake-to-qir-func",
   }];
 
   let options = [
-    Option<"convertTo", "convert-to", "std::string", "\"qir-base\"",
+    Option<"convertTo", "convert-to", "std::string", /*default=*/"\"qir-base\"",
            "Which QIR profile to convert to (default is 'qir-base')">
   ];
 
@@ -127,8 +110,10 @@ def QIRToQIRProfileFunc : Pass<"quake-to-qir-func",
 
 def QIRToQIRProfile : Pass<"convert-to-qir-profile"> {
   let summary =
-    "After lowering a Quake kernel to QIR, lower further to the specific QIR Profile.";
+    "Lower full QIR further to the specific QIR Profile.";
   let description = [{
+    This is run after lowering a Quake kernel to full QIR.
+
     This is a subpass of the pipeline to convert to the specific QIR Profile.
 
     This pass lowers various QIR DAGs to the specific QIR Profile. See
@@ -179,4 +164,52 @@ def VerifyNVQIRCallOps :
   let constructor = "cudaq::opt::createVerifyNVQIRCallOpsPass({})";
 }
 
+def VerifyQIRProfile : Pass<"verify-qir-profile", "mlir::LLVM::LLVMFuncOp"> {
+  let summary = "Verify that the output conforms to the specific profile";
+  let description = [{
+    This pass scans over functions in the LLVM-IR dialect to make sure they
+    conform to the QIR specific profile.
+  }];
+
+  let options = [
+    Option<"convertTo", "convert-to", "std::string", "\"qir-base\"",
+           "Which QIR profile to convert to (default is 'qir-base')">
+  ];
+}
+
+def WireSetToProfileQIR : Pass<"wireset-to-profile-qir", "mlir::func::FuncOp"> {
+  let summary = "Convert quake using wire sets to a profile of QIR";
+  let description = [{
+    This pass takes quake in "value semantics" form and after it has been
+    converted to use wire sets (qubit management, mapping, etc.) and converts
+    the code to CC dialect with QIR calls, etc.
+  }];
+
+  let dependentDialects = ["cudaq::cc::CCDialect", "mlir::LLVM::LLVMDialect"];
+  let options = [
+    Option<"convertTo", "convert-to", "std::string", /*default=*/"\"qir-base\"",
+           "Select the profile to convert wire sets to.">
+  ];
+}
+
+def WireSetToProfileQIRPost :
+    Pass<"wireset-to-profile-qir-post", "mlir::ModuleOp"> {
+  let summary = "Post processing for lowering wire sets to a profile of QIR";
+  let description = [{
+    This pass should be run immediately after wireset-to-profile-qir.
+  }];
+
+  let dependentDialects = ["cudaq::cc::CCDialect", "mlir::func::FuncDialect"];
+}
+
+def WireSetToProfileQIRPrep :
+    Pass<"wireset-to-profile-qir-prep", "mlir::ModuleOp"> {
+  let summary = "Prepare for lowering wire sets to a profile of QIR";
+  let description = [{
+    This pass should be run immediately before wireset-to-profile-qir.
+  }];
+
+  let dependentDialects = ["cudaq::cc::CCDialect", "mlir::func::FuncDialect"];
+}
+
 #endif // CUDAQ_OPT_OPTIMIZER_CODEGEN_PASSES

include/cudaq/Optimizer/CodeGen/QIRAttributeNames.h

@@ -0,0 +1,27 @@
+/****************************************************************-*- C++ -*-****
+ * Copyright (c) 2022 - 2024 NVIDIA Corporation & Affiliates.                  *
+ * All rights reserved.                                                        *
+ *                                                                             *
+ * This source code and the accompanying materials are made available under    *
+ * the terms of the Apache License 2.0 which accompanies this distribution.    *
+ ******************************************************************************/
+
+#pragma once
+
+/// This file provides some common QIR attribute names for use in code gen.
+
+namespace cudaq::opt {
+
+static constexpr const char QIRRegisterNameAttr[] = "registerName";
+static constexpr const char QIREntryPointAttrName[] = "entry_point";
+static constexpr const char QIRProfilesAttrName[] = "qir_profiles";
+static constexpr const char QIROutputLabelingSchemaAttrName[] =
+    "output_labeling_schema";
+static constexpr const char QIROutputNamesAttrName[] = "output_names";
+static constexpr const char QIRRequiredQubitsAttrName[] = "requiredQubits";
+static constexpr const char QIRRequiredResultsAttrName[] = "requiredResults";
+static constexpr const char QIRIrreversibleFlagName[] = "irreversible";
+
+static constexpr const char StartingOffsetAttrName[] = "StartingOffset";
+
+} // namespace cudaq::opt

include/cudaq/Optimizer/CodeGen/QIRFunctionNames.h

@@ -73,10 +73,21 @@ static constexpr const char QIRArrayConcatArray[] =
 static constexpr const char QIRArrayCreateArray[] =
     "__quantum__rt__array_create_1d";
 
+/// Dynamic qubit management helper functions. These are currently only used by
+/// the NVQIR simulator.
+static constexpr const char QIRisDynamicQubitManagement[] =
+    "__quantum__rt__is_dynamic_qubit_management";
+static constexpr const char QIRsetDynamicQubitManagement[] =
+    "__quantum__rt__set_dynamic_qubit_management";
+
 /// QIR Base/Adaptive Profile record output function names
 static constexpr const char QIRRecordOutput[] =
     "__quantum__rt__result_record_output";
 
+/// Custom NVQIR method to cleanup result maps in between consecutive programs.
+static constexpr const char QIRClearResultMaps[] =
+    "__quantum__rt__clear_result_maps";
+
 inline mlir::Type getQuantumTypeByName(mlir::StringRef type,
                                        mlir::MLIRContext *context) {
   return mlir::LLVM::LLVMStructType::getOpaque(type, context);

include/cudaq/Optimizer/Dialect/Quake/QuakeOps.h

@@ -70,6 +70,13 @@ void genericOpPrinter(mlir::OpAsmPrinter &_odsPrinter, mlir::Operation *op,
 // Utility functions to test the form of an operation.
 //===----------------------------------------------------------------------===//
 
+// Is \p op in the Quake dialect?
+inline bool isQuakeOperation(mlir::Operation *op) {
+  if (auto *dialect = op->getDialect())
+    return dialect->getNamespace().equals("quake");
+  return false;
+}
+
 namespace quake {
 /// Returns true if and only if any quantum operand has type `!quake.ref` or
 /// `!quake.veq`.

include/cudaq/Optimizer/Transforms/Passes.td

@@ -184,7 +184,8 @@ def DelayMeasurements : Pass<"delay-measurements", "mlir::func::FuncOp"> {
     "Move measurements as late as possible";
 
   let description = [{
-    Move measurements as late as possible. This is useful for a Base Profile QIR program.
+    Move measurements as late as possible. This is useful for a Base Profile
+    QIR program.
   }];
 
   let constructor = "cudaq::opt::createDelayMeasurementsPass()";
@@ -214,6 +215,49 @@ def DecompositionPass: Pass<"decomposition", "mlir::ModuleOp"> {
   ];
 }
 
+def DependencyAnalysis : Pass<"dep-analysis", "mlir::ModuleOp"> {
+  let summary = "Maps qubits and reorders operations based on dependency graph.";
+  let description = [{
+    A dependency graph is a Directed Acyclic Graph (DAG) where each node
+    represents an operation, and each edge represents a "depends on" relation
+    between that operation and another operation. For example, in the following
+    snippet the `x` operation depends on the `h` operation because it is applied
+    to the same qubit (`q`), so the `h` operation must happen before the `x`
+    operation:
+    ```c++
+      cudaq::qubit q;
+      x(q);
+      h(q);
+    ```
+
+    Once a dependency graph is created, it is then scheduled, assigning each
+    operation a virtual cycle. Operations that don't depend on each other may
+    be scheduled at the same cycle. However, an operation that depends on a
+    second operation must be scheduled after the second operation. The
+    scheduling algorithm tries to pack operations as densely as possible,
+    minimizing the number of cycles between operations.
+
+    From this dependency graph, we can calculate the lifetime of a qubit: from
+    the cycle in which it is first used through the cycle in which it is last
+    used. If two virtual qubits have non-overlapping lifetimes, they can be
+    assigned to the same physical qubit, as every virtual qubit is assumed to be
+    fully reset before release. Failure to fully reset virtual qubits before
+    release is undefinied behavior, and will likely lead to incorrect output
+    when running DependencyAnalysis.
+  }];
+
+  let dependentDialects = ["quake::QuakeDialect"];
+
+  let statistics = [
+    Statistic<"numVirtualQubits", "num-virtual-qubits",
+              "Number of virtual qubits used">,
+    Statistic<"numPhysicalQubits", "num-physical-qubits",
+              "Number of phyiscal qubits used">,
+    Statistic<"numCycles", "num-cycles",
+              "Length of kernel in cycles">,
+  ];
+}
+
 def EraseNopCalls : Pass<"erase-nop-calls", "mlir::func::FuncOp"> {
   let summary = "Erase calls to any builtin intrinsics that are NOPs.";
   let description = [{

include/cudaq/Support/TargetConfig.h

@@ -24,6 +24,8 @@ enum TargetFeatureFlag : unsigned {
   flagsFP64 = 0x0002,
   flagsMgpu = 0x0004,
   flagsMqpu = 0x0008,
+  flagsDepAnalysis = 0x0010,
+  flagsQPP = 0x0020,
 };
 
 /// @brief Configuration argument type annotation
@@ -69,6 +71,8 @@ struct BackendEndConfigEntry {
   std::optional<bool> LibraryMode;
   /// IR lowering configuration (hardware REST QPU)
   std::string PlatformLoweringConfig;
+  /// Exact cudaq-opt passes for pseudo-targets
+  std::string TargetPassPipeline;
   /// Codegen emission configuration (hardware REST QPU)
   std::string CodegenEmission;
   /// Post code generation IR passes configuration (hardware REST QPU)

lib/Optimizer/CodeGen/CMakeLists.txt

@@ -28,6 +28,8 @@ add_cudaq_library(OptCodeGen
   TranslateToIQMJson.cpp
   TranslateToOpenQASM.cpp
   VerifyNVQIRCalls.cpp
+  VerifyQIRProfile.cpp
+  WireSetsToProfileQIR.cpp
 
   DEPENDS
     CCDialect

lib/Optimizer/CodeGen/ConvertToQIR.cpp

@@ -68,7 +68,7 @@ class ConvertToQIR : public cudaq::opt::impl::ConvertToQIRBase<ConvertToQIR> {
   /// Measurement counter for unnamed measurements. Resets every module.
   unsigned measureCounter = 0;
 
-  // This is an ad hox transformation to convert constant array values into a
+  // This is an ad hoc transformation to convert constant array values into a
   // buffer of constants.
   LogicalResult eraseConstantArrayOps() {
     bool ok = true;