remove --many-seeds from ./miri run

Author: RalfJung

src/tools/miri/ci/ci.sh

@@ -66,9 +66,9 @@ function run_tests {
     time MIRIFLAGS="${MIRIFLAGS-} -O -Zmir-opt-level=4 -Cdebug-assertions=yes" MIRI_SKIP_UI_CHECKS=1 ./miri test $TARGET_FLAG tests/{pass,panic}
   fi
   if [ -n "${MANY_SEEDS-}" ]; then
-    # Also run some many-seeds tests. (Also tests `./miri run`.)
+    # Run many-seeds tests. (Also tests `./miri run`.)
     time for FILE in tests/many-seeds/*.rs; do
-      ./miri run "--many-seeds=0..$MANY_SEEDS" $TARGET_FLAG "$FILE"
+      ./miri run "-Zmiri-many-seeds=0..$MANY_SEEDS" $TARGET_FLAG "$FILE"
     done
   fi
   if [ -n "${TEST_BENCH-}" ]; then

src/tools/miri/miri-script/src/commands.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
 use std::io::{BufReader, BufWriter, Write};
-use std::ops::{Not, Range};
+use std::ops::Not;
 use std::path::PathBuf;
 use std::time::Duration;
 use std::{env, net, process};
@@ -178,8 +178,8 @@ impl Command {
             Command::Check { flags } => Self::check(flags),
             Command::Test { bless, flags, target, coverage } =>
                 Self::test(bless, flags, target, coverage),
-            Command::Run { dep, verbose, many_seeds, target, edition, flags } =>
-                Self::run(dep, verbose, many_seeds, target, edition, flags),
+            Command::Run { dep, verbose, target, edition, flags } =>
+                Self::run(dep, verbose, target, edition, flags),
             Command::Doc { flags } => Self::doc(flags),
             Command::Fmt { flags } => Self::fmt(flags),
             Command::Clippy { flags } => Self::clippy(flags),
@@ -586,7 +586,6 @@ impl Command {
     fn run(
         dep: bool,
         verbose: bool,
-        many_seeds: Option<Range<u32>>,
         target: Option<String>,
         edition: Option<String>,
         flags: Vec<String>,
@@ -614,48 +613,34 @@ impl Command {
         early_flags.push("--sysroot".into());
         early_flags.push(miri_sysroot.into());
 
-        // Compute everything needed to run the actual command. Also add MIRIFLAGS.
+        // Compute flags.
         let miri_flags = e.sh.var("MIRIFLAGS").unwrap_or_default();
         let miri_flags = flagsplit(&miri_flags);
         let quiet_flag = if verbose { None } else { Some("--quiet") };
-        // This closure runs the command with the given `seed_flag` added between the MIRIFLAGS and
-        // the `flags` given on the command-line.
-        let run_miri = |e: &MiriEnv, seed_flag: Option<String>| -> Result<()> {
-            // The basic command that executes the Miri driver.
-            let mut cmd = if dep {
-                // We invoke the test suite as that has all the logic for running with dependencies.
-                e.cargo_cmd(".", "test")
-                    .args(&["--test", "ui"])
-                    .args(quiet_flag)
-                    .arg("--")
-                    .args(&["--miri-run-dep-mode"])
-            } else {
-                cmd!(e.sh, "{miri_bin}")
-            };
-            cmd.set_quiet(!verbose);
-            // Add Miri flags
-            let mut cmd = cmd.args(&miri_flags).args(&seed_flag).args(&early_flags).args(&flags);
-            // For `--dep` we also need to set the target in the env var.
-            if dep {
-                if let Some(target) = &target {
-                    cmd = cmd.env("MIRI_TEST_TARGET", target);
-                }
-            }
-            // And run the thing.
-            Ok(cmd.run()?)
-        };
-        // Run the closure once or many times.
-        if let Some(seed_range) = many_seeds {
-            e.run_many_times(seed_range, |e, seed| {
-                eprintln!("Trying seed: {seed}");
-                run_miri(e, Some(format!("-Zmiri-seed={seed}"))).inspect_err(|_| {
-                    eprintln!("FAILING SEED: {seed}");
-                })
-            })?;
+
+        // Run Miri.
+        // The basic command that executes the Miri driver.
+        let mut cmd = if dep {
+            // We invoke the test suite as that has all the logic for running with dependencies.
+            e.cargo_cmd(".", "test")
+                .args(&["--test", "ui"])
+                .args(quiet_flag)
+                .arg("--")
+                .args(&["--miri-run-dep-mode"])
         } else {
-            run_miri(&e, None)?;
+            cmd!(e.sh, "{miri_bin}")
+        };
+        cmd.set_quiet(!verbose);
+        // Add Miri flags
+        let mut cmd = cmd.args(&miri_flags).args(&early_flags).args(&flags);
+        // For `--dep` we also need to set the target in the env var.
+        if dep {
+            if let Some(target) = &target {
+                cmd = cmd.env("MIRI_TEST_TARGET", target);
+            }
         }
-        Ok(())
+        // Finally, run the thing.
+        Ok(cmd.run()?)
     }
 
     fn fmt(flags: Vec<String>) -> Result<()> {

src/tools/miri/miri-script/src/main.rs

@@ -4,29 +4,9 @@ mod commands;
 mod coverage;
 mod util;
 
-use std::ops::Range;
-
-use anyhow::{Context, Result, anyhow, bail};
+use anyhow::{Result, bail};
 use clap::{Parser, Subcommand};
 
-/// Parses a seed range
-///
-/// This function is used for the `--many-seeds` flag. It expects the range in the form
-/// `<from>..<to>`. `<from>` is inclusive, `<to>` is exclusive. `<from>` can be omitted,
-/// in which case it is assumed to be `0`.
-fn parse_range(val: &str) -> anyhow::Result<Range<u32>> {
-    let (from, to) = val
-        .split_once("..")
-        .ok_or_else(|| anyhow!("invalid format for `--many-seeds`: expected `from..to`"))?;
-    let from: u32 = if from.is_empty() {
-        0
-    } else {
-        from.parse().context("invalid `from` in `--many-seeds=from..to")?
-    };
-    let to: u32 = to.parse().context("invalid `to` in `--many-seeds=from..to")?;
-    Ok(from..to)
-}
-
 #[derive(Clone, Debug, Subcommand)]
 pub enum Command {
     /// Installs the miri driver and cargo-miri to the sysroot of the active toolchain.
@@ -81,9 +61,6 @@ pub enum Command {
         /// Show build progress.
         #[arg(long, short)]
         verbose: bool,
-        /// Run the driver with the seeds in the given range (`..to` or `from..to`, default: `0..64`).
-        #[arg(long, value_parser = parse_range)]
-        many_seeds: Option<Range<u32>>,
         /// The cross-interpretation target.
         #[arg(long)]
         target: Option<String>,

src/tools/miri/miri-script/src/util.rs

@@ -1,9 +1,7 @@
 use std::ffi::{OsStr, OsString};
 use std::io::BufRead;
-use std::ops::Range;
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
-use std::{env, iter, thread};
+use std::{env, iter};
 
 use anyhow::{Context, Result, anyhow, bail};
 use dunce::canonicalize;
@@ -29,7 +27,6 @@ pub fn flagsplit(flags: &str) -> Vec<String> {
 }
 
 /// Some extra state we track for building Miri, such as the right RUSTFLAGS.
-#[derive(Clone)]
 pub struct MiriEnv {
     /// miri_dir is the root of the miri repository checkout we are working in.
     pub miri_dir: PathBuf,
@@ -240,53 +237,4 @@ impl MiriEnv {
 
         Ok(())
     }
-
-    /// Run the given closure many times in parallel with access to the shell, once for each value in the `range`.
-    pub fn run_many_times(
-        &self,
-        range: Range<u32>,
-        run: impl Fn(&Self, u32) -> Result<()> + Sync,
-    ) -> Result<()> {
-        // `next` is atomic so threads can concurrently fetch their next value to run.
-        let next = AtomicU32::new(range.start);
-        let end = range.end; // exclusive!
-        let failed = AtomicBool::new(false);
-        thread::scope(|s| {
-            let mut handles = Vec::new();
-            // Spawn one worker per core.
-            for _ in 0..thread::available_parallelism()?.get() {
-                // Create a copy of the environment for this thread.
-                let local_miri = self.clone();
-                let handle = s.spawn(|| -> Result<()> {
-                    let local_miri = local_miri; // move the copy into this thread.
-                    // Each worker thread keeps asking for numbers until we're all done.
-                    loop {
-                        let cur = next.fetch_add(1, Ordering::Relaxed);
-                        if cur >= end {
-                            // We hit the upper limit and are done.
-                            break;
-                        }
-                        // Run the command with this seed.
-                        run(&local_miri, cur).inspect_err(|_| {
-                            // If we failed, tell everyone about this.
-                            failed.store(true, Ordering::Relaxed);
-                        })?;
-                        // Check if some other command failed (in which case we'll stop as well).
-                        if failed.load(Ordering::Relaxed) {
-                            return Ok(());
-                        }
-                    }
-                    Ok(())
-                });
-                handles.push(handle);
-            }
-            // Wait for all workers to be done.
-            for handle in handles {
-                handle.join().unwrap()?;
-            }
-            // If all workers succeeded, we can't have failed.
-            assert!(!failed.load(Ordering::Relaxed));
-            Ok(())
-        })
-    }
 }