Merge branch 'main' into add-patch-pypi.sh

Author: mitchdz

docker/release/cudaq.nvqc.Dockerfile

@@ -10,12 +10,36 @@
 #
 # Usage:
 # Must be built from the repo root with:
-#   docker build -f docker/release/cudaq.nvqc.Dockerfile .
+#   # to skip prerequisites (default)
+#   docker build --target=without_tpls -f docker/release/cudaq.nvqc.Dockerfile .
+#
+#   # to install and clone prerequisites
+#   docker build --target=with_tpls \
+#       -f docker/release/cudaq.nvqc.Dockerfile .
 
 # Base image is CUDA-Q image 
 ARG base_image=nvcr.io/nvidia/nightly/cuda-quantum:cu12-latest
 FROM $base_image AS nvcf_image
 
+# With prerequisites
+FROM $base_image AS with_tpls
+RUN echo "Build with prerequisites"
+# COPY install_prerequisites into the image
+RUN sudo mkdir -p /tmp
+COPY --chmod=0755 scripts/install_prerequisites.sh /tmp/install_prerequisites.sh
+COPY .gitmodules /tmp/.gitmodules
+# Manually run this command locally to create tpls_commits.lock file
+# git config --file .gitmodules --get-regexp '^submodule\..*\.path$' \
+#         | awk '{print $2}' \
+#         | while read p; do printf "%s %s\n" "$(git rev-parse HEAD:$p)" "$p"; done \
+#         > tpls_commits.lock
+COPY tpls_commits.lock /tmp/tpls_commits.lock
+RUN sudo bash /tmp/install_prerequisites.sh -l /tmp/tpls_commits.lock
+
+# Without prerequisites
+FROM $base_image AS without_tpls
+RUN echo "Default build without prerequisites"
+
 # Run the tar command and then uncomment ADD cudaq.tar.gz ... in order to
 # override the installation.
 # tar czvf /workspaces/cuda-quantum/cudaq.tar.gz -C /usr/local/cudaq .

docs/sphinx/api/languages/python_api.rst

@@ -84,6 +84,8 @@ Backend Configuration
 .. autofunction:: cudaq::reset_target
 .. autofunction:: cudaq::set_noise
 .. autofunction:: cudaq::unset_noise
+.. autofunction:: cudaq::register_set_target_callback
+.. autofunction:: cudaq::unregister_set_target_callback
 
 .. function:: cudaq.apply_noise(error_type, parameters..., targets...)
 

docs/sphinx/examples/python/random_walk_qpe.py

@@ -35,13 +35,13 @@ def rwpe_kernel(n_iter: int, mu: float, sigma: float) -> float:
         x.ctrl(aux, target)
         h(aux)
         if mz(aux):
-            x(aux)
             mu = mu + sigma * .6065
         else:
             mu = mu - sigma * .6065
 
         sigma *= .7951
         iteration += 1
+        reset(aux)
 
     return 2.0 * mu
 

docs/sphinx/using/extending/backend.rst

@@ -225,7 +225,7 @@ Create a ``YAML`` configuration file for your target:
       preprocessor-defines: ["-D CUDAQ_QUANTUM_DEVICE"]
       # Define the lowering pipeline
       # This will cover applying hardware-specific constraints since each provider may have different native gate sets, requiring custom mappings and decompositions. You may need assistance from the CUDA-Q team to set this up correctly.
-      platform-lowering-config: "classical-optimization-pipeline,globalize-array-values,func.func(state-prep),unitary-synthesis,canonicalize,apply-op-specialization,aggressive-early-inlining,classical-optimization-pipeline,lower-to-cfg,func.func(canonicalize,multicontrol-decomposition),decomposition{enable-patterns=U3ToRotations},symbol-dce,<provider_name>-gate-set-mapping"
+      platform-lowering-config: "classical-optimization-pipeline,globalize-array-values,func.func(state-prep),unitary-synthesis,canonicalize,apply-op-specialization,aggressive-inlining,classical-optimization-pipeline,lower-to-cfg,func.func(canonicalize,multicontrol-decomposition),decomposition{enable-patterns=U3ToRotations},symbol-dce,<provider_name>-gate-set-mapping"
       # Tell the rest-qpu that we are generating QIR base profile.
       # As of the time of this writing, qasm2, qir-base and qir-adaptive are supported.
       codegen-emission: qir-base

include/cudaq/Optimizer/InitAllPasses.h

@@ -20,7 +20,7 @@ inline void registerCudaqPassesAndPipelines() {
   opt::registerOptTransformsPasses();
 
   // CUDA-Q pipelines
-  opt::registerAggressiveEarlyInliningPipeline();
+  opt::registerAggressiveInliningPipeline();
   opt::registerUnrollingPipeline();
   opt::registerClassicalOptimizationPipeline();
   opt::registerToExecutionManagerCCPipeline();

include/cudaq/Optimizer/Transforms/Passes.h

@@ -21,9 +21,8 @@ namespace cudaq::opt {
 /// Add a pass pipeline to transform call between kernels to direct calls that
 /// do not go through the runtime layers, inline all calls, and detect if calls
 /// to kernels remain in the fully inlined into entry point kernel.
-void addAggressiveEarlyInlining(mlir::OpPassManager &pm,
-                                bool fatalCheck = false);
-void registerAggressiveEarlyInliningPipeline();
+void addAggressiveInlining(mlir::OpPassManager &pm, bool fatalCheck = false);
+void registerAggressiveInliningPipeline();
 
 void registerUnrollingPipeline();
 void registerClassicalOptimizationPipeline();

lib/Optimizer/CodeGen/Pipelines.cpp

@@ -17,7 +17,7 @@ void cudaq::opt::commonPipelineConvertToQIR(PassManager &pm,
   auto passConfigFields = passConfigAs.split(':');
 
   pm.addNestedPass<func::FuncOp>(createApplyControlNegations());
-  addAggressiveEarlyInlining(pm);
+  addAggressiveInlining(pm);
   pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
   pm.addNestedPass<func::FuncOp>(createUnwindLowering());
   pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
@@ -40,7 +40,7 @@ void cudaq::opt::commonPipelineConvertToQIR(PassManager &pm,
   pm.addPass(createApplySpecialization());
   // If there was any specialization, we want another round in inlining to
   // inline the apply calls properly.
-  addAggressiveEarlyInlining(pm);
+  addAggressiveInlining(pm);
   addLowerToCFG(pm);
   pm.addNestedPass<func::FuncOp>(createCombineQuantumAllocations());
   pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());

lib/Optimizer/Transforms/AggressiveEarlyInlining.cpp renamed to lib/Optimizer/Transforms/AggressiveInlining.cpp

@@ -22,7 +22,7 @@ namespace cudaq::opt {
 #include "cudaq/Optimizer/Transforms/Passes.h.inc"
 } // namespace cudaq::opt
 
-#define DEBUG_TYPE "aggressive-early-inlining"
+#define DEBUG_TYPE "aggressive-inlining"
 
 using namespace mlir;
 
@@ -141,8 +141,7 @@ static void defaultInlinerOptPipeline(OpPassManager &pm) {
 /// Such a failure is most likely a sign that there is a cycle in the call
 /// graph. [This check is a bad idea: this should be deferred to final codegen
 /// when translating the final Quake IR.]
-void cudaq::opt::addAggressiveEarlyInlining(OpPassManager &pm,
-                                            bool fatalChecks) {
+void cudaq::opt::addAggressiveInlining(OpPassManager &pm, bool fatalChecks) {
   llvm::StringMap<OpPassManager> opPipelines;
   pm.addPass(cudaq::opt::createConvertToDirectCalls());
   pm.addPass(createInlinerPass(opPipelines, defaultInlinerOptPipeline));
@@ -152,8 +151,8 @@ void cudaq::opt::addAggressiveEarlyInlining(OpPassManager &pm,
 }
 
 namespace {
-struct AggressiveEarlyInliningPipelineOptions
-    : public PassPipelineOptions<AggressiveEarlyInliningPipelineOptions> {
+struct AggressiveInliningPipelineOptions
+    : public PassPipelineOptions<AggressiveInliningPipelineOptions> {
   // Running the inlining checks here defeats the compiler engineering principle
   // of having composable passes. It is therefore highly discouraged.
   PassOptions::Option<bool> runFatalChecker{
@@ -163,11 +162,11 @@ struct AggressiveEarlyInliningPipelineOptions
 };
 } // namespace
 
-void cudaq::opt::registerAggressiveEarlyInliningPipeline() {
-  PassPipelineRegistration<AggressiveEarlyInliningPipelineOptions>(
-      "aggressive-early-inlining",
+void cudaq::opt::registerAggressiveInliningPipeline() {
+  PassPipelineRegistration<AggressiveInliningPipelineOptions>(
+      "aggressive-inlining",
       "Convert calls between kernels to direct calls and inline functions.",
-      [](OpPassManager &pm, const AggressiveEarlyInliningPipelineOptions &opt) {
-        addAggressiveEarlyInlining(pm, opt.runFatalChecker);
+      [](OpPassManager &pm, const AggressiveInliningPipelineOptions &opt) {
+        addAggressiveInlining(pm, opt.runFatalChecker);
       });
 }

lib/Optimizer/Transforms/CMakeLists.txt

@@ -12,7 +12,7 @@ endif()
 
 add_cudaq_library(OptTransforms
   AddDeallocs.cpp
-  AggressiveEarlyInlining.cpp
+  AggressiveInlining.cpp
   ApplyControlNegations.cpp
   ApplyOpSpecialization.cpp
   ArgumentSynthesis.cpp

python/cudaq/__init__.py

@@ -125,6 +125,8 @@
 num_available_gpus = cudaq_runtime.num_available_gpus
 set_noise = cudaq_runtime.set_noise
 unset_noise = cudaq_runtime.unset_noise
+register_set_target_callback = cudaq_runtime.register_set_target_callback
+unregister_set_target_callback = cudaq_runtime.unregister_set_target_callback
 
 # Noise Modeling
 KrausChannel = cudaq_runtime.KrausChannel