Split QIR capabilities to pecos-qir crate

Author: ciaranra

Cargo.lock

@@ -47,6 +47,7 @@ pecos-core = { version = "0.1.1", path = "crates/pecos-core" }
 pecos-qsim = { version = "0.1.1", path = "crates/pecos-qsim" }
 pecos-qasm = { version = "0.1.1", path = "crates/pecos-qasm" }
 pecos-engines = { version = "0.1.1", path = "crates/pecos-engines" }
+pecos-qir = { version = "0.1.1", path = "crates/pecos-qir" }
 pecos-qec = { version = "0.1.1", path = "crates/pecos-qec" }
 pecos = { version = "0.1.1", path = "crates/pecos" }
 pecos-cli = { version = "0.1.1", path = "crates/pecos-cli" }

Cargo.toml

@@ -22,7 +22,7 @@ calls to Wasm VMs, conditional branching, and more.
 - Fast Simulation: Leverages a fast stabilizer simulation algorithm.
 - Multi-language extensions: Core functionalities implemented via Rust for performance and safety. Additional add-ons
 and extension support in C/C++ via Cython.
-- QIR Support: Execute Quantum Intermediate Representation programs (requires LLVM version 14 with the 'llc' tool).
+- QIR Support: Execute Quantum Intermediate Representation programs (requires LLVM version 14 with the 'llc' tool). PECOS now includes a dedicated `pecos-qir` crate with an improved QIR implementation.
 
 ## Getting Started
 
@@ -40,6 +40,10 @@ PECOS now consists of multiple interconnected components:
   - `/crates/pecos-core/`: Core Rust functionalities
   - `/crates/pecos-qsims/`: A collection of quantum simulators
   - `/crates/pecos-qec/`: Rust code for analyzing and exploring quantum error correction (QEC)
+  - `/crates/pecos-qasm/`: Implementation of QASM parsing and execution
+  - `/crates/pecos-qir/`: Implementation of QIR (Quantum Intermediate Representation) execution
+  - `/crates/pecos-engines/`: Quantum and classical engines for simulations
+  - `/crates/pecos-cli/`: Command-line interface for PECOS
   - `/crates/pecos-python/`: Rust code for Python extensions
   - `/crates/benchmarks/`: A collection of benchmarks to test the performance of the crates
 

README.md

@@ -30,17 +30,7 @@ pub fn setup_cli_engine(
     match program_type {
         ProgramType::QIR => {
             debug!("Setting up QIR engine");
-            let mut engine = QirEngine::new(program_path.to_path_buf());
-
-            // Set the number of shots assigned to this engine if specified
-            if let Some(num_shots) = shots {
-                engine.set_assigned_shots(num_shots)?;
-            }
-
-            // Pre-compile the QIR library for efficient cloning
-            engine.pre_compile()?;
-
-            Ok(Box::new(engine))
+            setup_qir_engine(program_path, shots)
         }
         ProgramType::PHIR => {
             debug!("Setting up PHIR engine");

crates/pecos-cli/src/engine_setup.rs

@@ -1,5 +1,6 @@
 use clap::{Args, Parser, Subcommand};
 use env_logger::Env;
+use log::debug;
 use pecos::prelude::*;
 
 mod engine_setup;
@@ -93,7 +94,7 @@ impl std::str::FromStr for OutputFormatType {
     }
 }
 
-#[derive(Args)]
+#[derive(Args, Clone)]
 struct RunArgs {
     /// Path to the quantum program (LLVM IR, JSON, or QASM)
     program: String,
@@ -227,15 +228,15 @@ fn parse_general_noise_probabilities(noise_str_opt: Option<&String>) -> (f64, f6
     }
 }
 
-/// Run a quantum program with the specified arguments
-///
-/// This function sets up the appropriate engines and noise models based on
-/// the command line arguments, then runs the specified program and outputs
-/// the results.
 fn run_program(args: &RunArgs) -> Result<(), PecosError> {
     // get_program_path now includes proper context in its errors
     let program_path = get_program_path(&args.program)?;
 
+    // Detect the program type (for informational purposes)
+    let program_type = detect_program_type(&program_path)?;
+    debug!("Detected program type: {:?}", program_type);
+
+    // Set up the engine
     let classical_engine =
         setup_cli_engine(&program_path, Some(args.shots.div_ceil(args.workers)))?;
 

crates/pecos-cli/src/main.rs

@@ -11,7 +11,6 @@ keywords.workspace = true
 categories.workspace = true
 description = "Provides simulator engines for PECOS simulations."
 
-
 [lib]
 crate-type = ["cdylib", "rlib"]
 
@@ -25,8 +24,6 @@ rand_chacha.workspace = true
 bytemuck.workspace = true
 bitflags.workspace = true
 dyn-clone.workspace = true
-libloading.workspace = true
-regex.workspace = true
 
 pecos-core.workspace = true
 pecos-qsim.workspace = true

crates/pecos-engines/Cargo.toml

@@ -3,7 +3,6 @@ pub mod hybrid;
 pub mod monte_carlo;
 pub mod noise;
 pub mod phir;
-pub mod qir;
 pub mod quantum;
 pub mod quantum_system;
 

crates/pecos-engines/src/engines.rs

@@ -1,6 +1,6 @@
 use crate::byte_message::ByteMessage;
 use crate::core::shot_results::ShotResult;
-use crate::engines::{ControlEngine, Engine, EngineStage, phir, qir};
+use crate::engines::{ControlEngine, Engine, EngineStage, phir};
 use dyn_clone::DynClone;
 use log::debug;
 use pecos_core::errors::PecosError;
@@ -188,36 +188,6 @@ impl Engine for Box<dyn ClassicalEngine> {
     }
 }
 
-/// Sets up a basic QIR engine.
-///
-/// This function creates a QIR engine from the provided path.
-///
-/// # Parameters
-///
-/// - `program_path`: A reference to the path of the QIR program file
-/// - `shots`: Optional number of shots to set for the engine
-///
-/// # Returns
-///
-/// Returns a `Box<dyn ClassicalEngine>` containing the QIR engine
-pub fn setup_qir_engine(
-    program_path: &Path,
-    shots: Option<usize>,
-) -> Result<Box<dyn ClassicalEngine>, PecosError> {
-    debug!("Setting up QIR engine for: {}", program_path.display());
-    let mut engine = qir::QirEngine::new(program_path.to_path_buf());
-
-    // Set the number of shots assigned to this engine if specified
-    if let Some(num_shots) = shots {
-        engine.set_assigned_shots(num_shots)?;
-    }
-
-    // Pre-compile the QIR library to prepare for efficient cloning
-    engine.pre_compile()?;
-
-    Ok(Box::new(engine))
-}
-
 /// Sets up a basic PHIR engine.
 ///
 /// This function creates a PHIR engine from the provided path.

crates/pecos-engines/src/engines/classical.rs

@@ -13,11 +13,10 @@ pub use engines::{
     monte_carlo::MonteCarloEngine,
     noise::{DepolarizingNoiseModel, NoiseModel, PassThroughNoiseModel},
     phir::PHIREngine,
-    qir::QirEngine,
     quantum::QuantumEngine,
     quantum_system::QuantumSystem,
 };
 pub use pecos_core::errors::PecosError;
 
 // Re-export engine setup functions
-pub use engines::classical::{setup_phir_engine, setup_qir_engine};
+pub use engines::classical::setup_phir_engine;

crates/pecos-engines/src/lib.rs

@@ -0,0 +1,25 @@
+[package]
+name = "pecos-qir"
+version.workspace = true
+edition.workspace = true
+readme.workspace = true
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+keywords.workspace = true
+categories.workspace = true
+description = "QIR (Quantum Intermediate Representation) execution capabilities for PECOS."
+
+[dependencies]
+log.workspace = true
+pecos-core.workspace = true
+pecos-engines.workspace = true
+regex.workspace = true
+libloading.workspace = true
+
+[build-dependencies]
+# No specific build dependencies required
+
+[lints]
+workspace = true