Method concurrent_transform

src/execution/mod.rs:658–714

concurrently transform programs to fuzzers.

(
        &self,
        programs: &Vec<PathBuf>,
        core: usize,
        use_cons: bool,
        corpus: &Vec<PathBuf>,
    )

    /// concurrently transform programs to fuzzers.
    pub fn concurrent_transform(
        &self,
        programs: &Vec<PathBuf>,
        core: usize,
        use_cons: bool,
        corpus: &Vec<PathBuf>,
    ) -> Result<()> {
        let pool = ThreadPool::new(core);
        let error_occurred = Arc::new(AtomicBool::new(false));

        for (i, program) in programs.iter().enumerate() {
            let error_occurred = Arc::clone(&error_occurred);
            let program = program.clone();
            let corpora = corpus[i].clone();

            // the constraints are load in harness.
            pool.execute(move || {
                // If an error has occurred in another thread, stop this one
                if error_occurred.load(Ordering::SeqCst) {
                    return;
                }
                let mut cmd = Command::new("cargo");
                let cmd = cmd
                    .arg("run")
                    .arg("--bin")
                    .arg("harness")
                    .arg("--")
                    .arg(get_library_name())
                    .arg("transform")
                    .arg(&program);
                if use_cons {
                    cmd.arg("-u");
                    cmd.arg("-p");
                    cmd.arg(&corpora);
                }
                let output = cmd
                    .stdin(Stdio::null())
                    .stdout(Stdio::null())
                    .stderr(Stdio::piped())
                    .output()
                    .expect("failed to execute the concurrent transform process");
                if !output.status.success() {
                    error_occurred.store(true, Ordering::SeqCst);
                    log::error!(
                        "Transform {program:?} to fuzzer error!\n{}",
                        String::from_utf8_lossy(&output.stderr)
                    );
                }
            });
        }
        pool.join();
        if error_occurred.load(Ordering::SeqCst) {
            log::error!("Concurrent transform failed!");
            //eyre::bail!("Concurrent transform failed!");
        }
        Ok(())
    }