Address some feedback

Signed-off-by: Adam Geller <adgeller@nvidia.com>

Author: atgeller

python/tests/backends/test_pipeline_logging.py

@@ -15,7 +15,6 @@
 
 @pytest.fixture(autouse=True)
 def reset_target():
-    cudaq.reset_target()
     yield
     cudaq.reset_target()
 
@@ -52,10 +51,13 @@ def observe_kernel():
     h(qubit)
 
 
+PIPELINE_FILE = "pipeline.jsonl"
+
+
 @pytest.mark.parametrize("target,target_kwargs,supports_run", TARGET_CONFIGS)
 def test_pipeline_logging_decorator(tmp_path, monkeypatch, target,
                                     target_kwargs, supports_run):
-    log_path = tmp_path / "pipeline.jsonl"
+    log_path = tmp_path / PIPELINE_FILE
     monkeypatch.setenv("CUDAQ_PIPELINE_LOG", str(log_path))
 
     if not cudaq.has_target(target):
@@ -82,7 +84,7 @@ def test_pipeline_logging_decorator(tmp_path, monkeypatch, target,
 
 
 def test_pipeline_logging_builder_default(tmp_path, monkeypatch):
-    log_path = tmp_path / "pipeline.jsonl"
+    log_path = tmp_path / PIPELINE_FILE
     monkeypatch.setenv("CUDAQ_PIPELINE_LOG", str(log_path))
 
     kernel = cudaq.make_kernel()

runtime/common/BaseRestRemoteClient.h

@@ -206,8 +206,9 @@ class BaseRemoteRestRuntimeClient : public RemoteRuntimeClient {
         moduleOp.getContext()->disableMultithreading();
         pm.enableIRPrinting();
       }
-      cudaq_internal::maybeLogPassPipeline(pm,
-                                           name + ":" + passName + "-synth");
+
+      cudaq_internal::maybeLogPassPipeline(
+          pm, cudaq_internal::buildLabel(name, passName + "-synth"));
       if (failed(pm.run(moduleOp)))
         throw std::runtime_error("Could not successfully apply " + passName +
                                  " synth.");
@@ -250,7 +251,8 @@ class BaseRemoteRestRuntimeClient : public RemoteRuntimeClient {
     tm.setEnabled(cudaq::isTimingTagEnabled(cudaq::TIMING_JIT_PASSES));
     auto timingScope = tm.getRootScope(); // starts the timer
     pm.enableTiming(timingScope);         // do this right before pm.run
-    cudaq_internal::maybeLogPassPipeline(pm, name + ":client");
+    cudaq_internal::maybeLogPassPipeline(
+        pm, cudaq_internal::buildLabel(name, "client"));
     if (failed(pm.run(moduleOp)))
       throw std::runtime_error(
           "Remote rest platform: applying IR passes failed.");
@@ -304,7 +306,8 @@ class BaseRemoteRestRuntimeClient : public RemoteRuntimeClient {
     mlir::PassManager pm(ctx);
     // For now, the server side expects full-QIR.
     opt::addAOTPipelineConvertToQIR(pm);
-    cudaq_internal::maybeLogPassPipeline(pm, name + ":aot-qir");
+    cudaq_internal::maybeLogPassPipeline(
+        pm, cudaq_internal::buildLabel(name, "aot-qir"));
 
     if (failed(pm.run(moduleOp)))
       throw std::runtime_error(

runtime/common/Compiler.cpp

@@ -313,7 +313,8 @@ std::vector<cudaq::KernelExecution> Compiler::lowerQuakeCodePart2(
       moduleOp.getContext()->disableMultithreading();
     if (enablePrintMLIREachPass)
       pm.enableIRPrinting();
-    cudaq_internal::maybeLogPassPipeline(pm, kernelName + ":quake-synth");
+    cudaq_internal::maybeLogPassPipeline(
+        pm, cudaq_internal::buildLabel(kernelName, "quake-synth"));
     if (failed(pm.run(moduleOp)))
       throw std::runtime_error("Could not successfully apply quake-synth.");
   }
@@ -373,8 +374,9 @@ std::vector<cudaq::KernelExecution> Compiler::lowerQuakeCodePart2(
     pm.addPass(mlir::createCanonicalizerPass());
     if (enablePrintMLIREachPass)
       pm.enableIRPrinting();
-    cudaq_internal::maybeLogPassPipeline(pm, kernelName +
-                                                 ":resource-count-preprocess");
+    cudaq_internal::maybeLogPassPipeline(
+        pm,
+        cudaq_internal::buildLabel(kernelName, "resource-count-preprocess"));
     if (failed(pm.run(moduleOp)))
       throw std::runtime_error(
           "Could not successfully apply resource count preprocess.");
@@ -456,7 +458,8 @@ std::vector<cudaq::KernelExecution> Compiler::lowerQuakeCodePart2(
         tmpModuleOp.getContext()->disableMultithreading();
       if (enablePrintMLIREachPass)
         pm.enableIRPrinting();
-      cudaq_internal::maybeLogPassPipeline(pm, kernelName + ":observe-ansatz");
+      cudaq_internal::maybeLogPassPipeline(
+          pm, cudaq_internal::buildLabel(kernelName, "observe-ansatz"));
       if (failed(pm.run(tmpModuleOp)))
         throw std::runtime_error("Could not apply measurements to ansatz.");
       // The full pass pipeline was run above, but the ansatz pass can

runtime/common/PassPipelineLogging.h

@@ -27,4 +27,9 @@ std::string getPipelineLogPath();
 ///       This is the results of actually executing the passes
 void maybeLogPassPipeline(mlir::PassManager &pm, llvm::StringRef label = {});
 
+std::string buildLabel(const std::string &pipeline_name,
+                       const std::string &specifics) {
+  return pipeline_name + ":" + specifics;
+}
+
 } // namespace cudaq_internal

runtime/cudaq/platform/default/python/QPU.cpp

@@ -95,7 +95,8 @@ specializeKernel(const std::string &name, ModuleOp module,
     module.getContext()->disableMultithreading();
     pm.enableIRPrinting();
   }
-  cudaq_internal::maybeLogPassPipeline(pm, name + ":python-specialize");
+  cudaq_internal::maybeLogPassPipeline(
+      pm, cudaq_internal::buildLabel(name, "python-specialize"));
   if (failed(pm.run(module)))
     throw std::runtime_error("Could not successfully apply argument synth.");
 }
@@ -115,7 +116,8 @@ std::string cudaq::detail::lower_to_qir_llvm(const std::string &name,
   cudaq::opt::addAggressiveInlining(pm);
   cudaq::opt::createTargetFinalizePipeline(pm);
   cudaq::opt::addAOTPipelineConvertToQIR(pm, format);
-  cudaq_internal::maybeLogPassPipeline(pm, name + ":python-qir");
+  cudaq_internal::maybeLogPassPipeline(
+      pm, cudaq_internal::buildLabel(name, "python-qir"));
   if (failed(pm.run(module)))
     throw std::runtime_error("Conversion to " + format + " failed.");
   if (failed(cudaq::verifier::checkQIRLLVMIRDialect(module, format)))
@@ -154,7 +156,8 @@ std::string cudaq::detail::lower_to_openqasm(const std::string &name,
     ctx->disableMultithreading();
     pm.enableIRPrinting();
   }
-  cudaq_internal::maybeLogPassPipeline(pm, name + ":python-openqasm");
+  cudaq_internal::maybeLogPassPipeline(
+      pm, cudaq_internal::buildLabel(name, "python-openqasm"));
   if (failed(pm.run(module)))
     throw std::runtime_error("Conversion to OpenQASM failed.");
   std::string result;