Multiple file paths

#618

Author: epompeii

services/cli/src/bencher/sub/run/mod.rs

@@ -158,16 +158,18 @@ impl Run {
         let start_time = DateTime::now();
         let mut results = Vec::with_capacity(self.iter);
         for _ in 0..self.iter {
-            let output = self.runner.run(self.log).await?;
-            if output.is_success() {
-                results.push(output.result());
-            } else if self.allow_failure {
-                cli_eprintln_quietable!(self.log, "Skipping failure:\n{output}");
-            } else {
-                return Err(RunError::ExitStatus {
-                    runner: Box::new(self.runner.clone()),
-                    output,
-                });
+            let outputs = self.runner.run(self.log).await?;
+            for output in outputs {
+                if output.is_success() {
+                    results.push(output.result());
+                } else if self.allow_failure {
+                    cli_eprintln_quietable!(self.log, "Skipping failure:\n{output}");
+                } else {
+                    return Err(RunError::ExitStatus {
+                        runner: Box::new(self.runner.clone()),
+                        output,
+                    });
+                }
             }
         }
 

services/cli/src/bencher/sub/run/runner/command.rs

@@ -194,14 +194,20 @@ impl CommandOutput {
         Ok(self.output)
     }
 
-    pub fn build_with_file_path(mut self, file_path: &FilePath) -> Result<Output, RunError> {
+    pub fn build_with_file_path(self, file_path: &FilePath) -> Result<Vec<Output>, RunError> {
         debug_assert!(
             self.build_command.is_none(),
             "Build command should not be set for file path"
         );
         let results = file_path.get_results()?;
-        self.output.result = Some(results);
-        Ok(self.output)
+        let outputs = results
+            .into_iter()
+            .map(|result| Output {
+                result: Some(result),
+                ..self.output.clone()
+            })
+            .collect();
+        Ok(outputs)
     }
 
     pub fn build_with_file_size(mut self, file_size: &FileSize) -> Result<Output, RunError> {

services/cli/src/bencher/sub/run/runner/file_path.rs

@@ -5,20 +5,33 @@ use camino::Utf8PathBuf;
 use crate::RunError;
 
 #[derive(Debug, Clone)]
-pub struct FilePath(Utf8PathBuf);
+pub struct FilePath(Vec<Utf8PathBuf>);
 
 impl fmt::Display for FilePath {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
+        write!(
+            f,
+            "{}",
+            self.0
+                .iter()
+                .map(|p| p.as_str())
+                .collect::<Vec<&str>>()
+                .join(", ")
+        )
     }
 }
 
 impl FilePath {
-    pub fn new(file_path: Utf8PathBuf) -> Self {
-        Self(file_path)
+    pub fn new(file_paths: Vec<Utf8PathBuf>) -> Self {
+        Self(file_paths)
     }
 
-    pub fn get_results(&self) -> Result<String, RunError> {
-        std::fs::read_to_string(&self.0).map_err(RunError::OutputFileRead)
+    pub fn get_results(&self) -> Result<Vec<String>, RunError> {
+        let mut results = Vec::new();
+        for path in &self.0 {
+            let result = std::fs::read_to_string(path).map_err(RunError::OutputFileRead)?;
+            results.push(result);
+        }
+        Ok(results)
     }
 }

services/cli/src/bencher/sub/run/runner/mod.rs

@@ -50,15 +50,15 @@ impl TryFrom<CliRunCommand> for Runner {
                 Command::new_exec(program, arguments)
             };
             let build_time = cmd.build_time.then_some(BuildTime);
-            Ok(if let Some(file_path) = cmd.file {
-                Self::CommandToFile(command, FilePath::new(file_path))
+            Ok(if let Some(file_paths) = cmd.file {
+                Self::CommandToFile(command, FilePath::new(file_paths))
             } else if let Some(file_paths) = cmd.file_size {
                 Self::CommandToFileSize(command, build_time, FileSize::new(file_paths))
             } else {
                 Self::Command(command, build_time)
             })
-        } else if let Some(file_path) = cmd.file {
-            Ok(Self::File(FilePath::new(file_path)))
+        } else if let Some(file_paths) = cmd.file {
+            Ok(Self::File(FilePath::new(file_paths)))
         } else if let Some(file_paths) = cmd.file_size {
             Ok(Self::FileSize(FileSize::new(file_paths)))
         } else if let Some(pipe) = Pipe::new() {
@@ -103,20 +103,25 @@ impl fmt::Display for Runner {
 }
 
 impl Runner {
-    pub async fn run(&self, log: bool) -> Result<Output, RunError> {
+    pub async fn run(&self, log: bool) -> Result<Vec<Output>, RunError> {
         match self {
-            Self::Pipe(pipe) => Ok(pipe.output()),
-            Self::Command(command, build_time) => command.run(log, *build_time).await?.build(),
+            Self::Pipe(pipe) => Ok(pipe.output().into()),
+            Self::Command(command, build_time) => {
+                command.run(log, *build_time).await?.build().map(Into::into)
+            },
             Self::CommandToFile(command, file_path) => command
                 .run(log, None)
                 .await?
                 .build_with_file_path(file_path),
             Self::CommandToFileSize(command, build_time, file_size) => command
                 .run(log, *build_time)
                 .await?
-                .build_with_file_size(file_size),
+                .build_with_file_size(file_size)
+                .map(Into::into),
             Self::File(file_path) => CommandOutput::default().build_with_file_path(file_path),
-            Self::FileSize(file_size) => CommandOutput::default().build_with_file_size(file_size),
+            Self::FileSize(file_size) => CommandOutput::default()
+                .build_with_file_size(file_size)
+                .map(Into::into),
         }
     }
 }

services/cli/src/bencher/sub/run/runner/output.rs

@@ -38,6 +38,12 @@ impl fmt::Display for ExitStatus {
     }
 }
 
+impl From<Output> for Vec<Output> {
+    fn from(output: Output) -> Self {
+        vec![output]
+    }
+}
+
 impl Output {
     pub fn is_success(&self) -> bool {
         self.status.is_success()

services/cli/src/parser/run.rs

@@ -140,7 +140,7 @@ pub struct CliRunCommand {
 
     /// Benchmark command output file path
     #[clap(long, conflicts_with = "file_size")]
-    pub file: Option<Utf8PathBuf>,
+    pub file: Option<Vec<Utf8PathBuf>>,
 
     /// Track the size of a file at the given file path
     #[clap(long, conflicts_with = "file")]

services/console/src/chunks/docs-explanation/bencher-run/de/benchmark-command.mdx

@@ -3,38 +3,59 @@ import ExecForm from "../exec-form.mdx";
 
 ## Benchmark-Befehl
 
-Das erste Argument für `bencher run` ist der optionale Benchmark-Befehl.
-Dies ist der Befehl, der ausgeführt wird, um Ihr Benchmark-Harness zu starten.
+Das erste Argument von `bencher run` ist der optionale Benchmark-Befehl.
+Dies ist der Befehl, der ausgeführt wird und Ihr Benchmark-Harness aufruft.
 Er kann auch über die Umgebungsvariable `BENCHER_CMD` gesetzt werden.
 Standardmäßig wird dieser Befehl in einer Shell ausgeführt,
 die mit den Optionen [`--shell`][shell option] und [`--flag`][flag option] konfiguriert werden kann.
 Seine Ausgabe wird von einem [Benchmark-Harness-Adapter][benchmark harness adapters] geparst,
-der mit der Option [`--adapter`][adapter option] festgelegt werden kann.
-Wenn das Benchmark-Harness jedoch in eine Datei schreibt, dann muss auch die Option [`--file`][file option] verwendet werden, um den Pfad der Ausgabedatei anzugeben.
-Alternative, um die Größe der Ausgabedatei (z. B. Binärgröße) anstelle ihres Inhalts zu verfolgen,
+der mit der Option [`--adapter`][adapter option] gesetzt werden kann.
+Wenn das Benchmark-Harness jedoch in eine Datei schreibt, muss außerdem die Option [`--file`][file option] verwendet werden,
+um den Pfad der Ausgabedatei anzugeben.
+Alternativ, um die Größe der Ausgabedatei (z. B. Binärgröße) statt ihres Inhalts zu erfassen,
 verwenden Sie die Option [`--file-size`][file size option], um den Pfad der Ausgabedatei anzugeben.
 
-Wenn Sie bevorzugen, dass der Befehl nicht in einer Shell ausgeführt wird, können Sie den `--exec` Flag verwenden oder einfach zusätzliche Argumente zu Ihrem Befehl als zusätzliche Argumente zu `bencher run` hinzufügen.
+Wenn Sie nicht möchten, dass der Befehl in einer Shell ausgeführt wird, können Sie das Flag `--exec` verwenden oder zusätzliche Argumente für Ihren Befehl einfach als zusätzliche Argumente an `bencher run` übergeben.
 
-Shell-Formular:
+Shell-Form:
 <ShellForm />
 
-Ausführungsformular:
+Exec-Form:
 <ExecForm />
 
-Der Benchmark-Befehl kann mehrmals mit der Option [`--iter`][iter option] ausgeführt werden,
+Der Benchmark-Befehl kann mehrfach mit der Option [`--iter`][iter option] ausgeführt werden,
 und diese Ergebnisse können mit der Option [`--fold`][fold option] zu einem einzigen Ergebnis zusammengefasst werden.
 Wenn eine der Iterationen fehlschlägt, gilt der gesamte Befehl als fehlgeschlagen,
-es sei denn, der Flag [`--allow-failure`][allow failure flag] wird gesetzt.
+es sei denn, das Flag [`--allow-failure`][allow failure flag] ist gesetzt.
 
-Wenn der Benchmark-Befehl nicht angegeben ist, aber die Option [`--file`][file option] verwendet wird,
-dann wird `bencher run` stattdessen einfach den Pfad der Ausgabedatei lesen.
-Ähnlich, wenn der Benchmark-Befehl nicht angegeben ist, aber die Option [`--file-size`][file size option] verwendet wird,
-dann wird `bencher run` einfach die Größe der Datei am angegebenen Dateipfad lesen.
-Wenn weder der Benchmark-Befehl, die Option [`--file`][file option],
+Wenn der Benchmark-Befehl nicht angegeben ist, aber die Option [`--file`][file option],
+dann wird `bencher run` stattdessen einfach aus dem angegebenen Ausgabedateipfad lesen.
+Ähnlich, wenn der Benchmark-Befehl nicht angegeben ist, aber die Option [`--file-size`][file size option],
+dann liest `bencher run` stattdessen nur die Größe der Datei am angegebenen Pfad.
+Beide Optionen `--file` und `--file-size` können mehrfach angegeben werden, um aus mehreren Dateien zu lesen.
+
+<blockquote>
+<details>
+  <summary>🐰 Tipps zur Verwendung der <code>-&#8288;-file</code> Option</summary>
+  Die <code>-&#8288;-file</code>-Option kann verwendet werden, um Benchmark-Ergebnisse aus einer Datei zu lesen.
+  Sie können die <code>-&#8288;-file</code>-Option mehrfach angeben, um aus mehreren Dateien zu lesen.
+  Wenn Sie die <code>-&#8288;-file</code>-Option mehrfach angeben,
+  wird jede Datei als separate <code>iteration</code> des Benchmark-Befehls betrachtet.
+  Beim Anzeigen werden diese Ergebnisse in separaten Tabellen dargestellt.
+
+  Wenn Sie diese Ergebnisse zu einer einzigen <code>iteration</code> zusammenfassen möchten,
+  können Sie die Option <code>-&#8288;-iter</code> auf <code>1</code> setzen
+  und die Option <code>-&#8288;-fold</code> auf eine der Aggregatfunktionen <code>min</code>, <code>max</code> oder <code>median</code> setzen.
+  Dadurch werden die Ergebnisse zu einer einzigen <code>iteration</code> zusammengefasst
+  und in einer einzigen Tabelle angezeigt.
+  Setzen Sie die Option <code>-&#8288;-fold</code> <b>nicht</b> auf <code>mean</code>.
+</details>
+</blockquote>
+
+Wenn weder der Benchmark-Befehl noch die Option [`--file`][file option]
 noch die Option [`--file-size`][file size option] angegeben sind,
-wird `bencher run` stattdessen von `stdin` lesen.
-Dies ermöglicht es Ihnen, die Ausgabe eines anderen Befehls in eine Datei zu speichern oder in `bencher run` zu pipen.
+dann liest `bencher run` stattdessen von `stdin`.
+Das ermöglicht es Ihnen, die Ausgabe eines anderen Befehls in eine Datei zu speichern oder sie in `bencher run` zu pipen.
 
 [benchmark harness adapters]: /de/docs/explanation/adapters/
 

services/console/src/chunks/docs-explanation/bencher-run/en/benchmark-command.mdx

@@ -32,6 +32,26 @@ If the benchmark command is not specified but the [`--file`][file option] option
 then `bencher run` will just read from output file path instead.
 Similarly, if the the benchmark command is not specified but the [`--file-size`][file size option] option is,
 then `bencher run` will just read the size of the file at the given file path instead.
+Both `--file` and `--file-size` options can be specified multiple times to read from multiple files.
+
+<blockquote>
+<details>
+  <summary>🐰 Tips for using the <code>-&#8288;-file</code> option</summary>
+  The <code>-&#8288;-file</code> option can be used to read benchmark results from a file.
+  You can specify the <code>-&#8288;-file</code> option multiple times to read from multiple files.
+  If you do specify the <code>-&#8288;-file</code> option multiple times,
+  then each file will be considered a separate <code>iteration</code> of the benchmark command.
+  When displayed, these results will be shown in separate tables.
+
+  If you wish to combined these results into a single <code>iteration</code>,
+  then you can set the <code>-&#8288;-iter</code> option to <code>1</code>
+  and set the <code>-&#8288;-fold</code> option to either the <code>min</code>, <code>max</code>, or <code>median</code> aggregate functions.
+  This will fold the results into a single <code>iteration</code>
+  and display them in a single table.
+  Do <b>not</b> set the <code>-&#8288;-fold</code> option to <code>mean</code>.
+</details>
+</blockquote>
+
 If neither the benchmark command, [`--file`][file option] option,
 nor [`--file-size`][file size option] option are specified,
 then `bencher run` will read from `stdin` instead.

services/console/src/chunks/docs-explanation/bencher-run/es/benchmark-command.mdx

@@ -1,41 +1,61 @@
 import ShellForm from "../shell-form.mdx";
 import ExecForm from "../exec-form.mdx";
 
-## Comando de Benchmark
-
-El primer argumento para `bencher run` es el comando de benchmark opcional.
-Este es el comando que se ejecutará, invocando tu arnés de referencia.
-También se puede establecer usando la variable de entorno `BENCHER_CMD`.
-Por defecto, este comando se ejecuta en una shell,
-que se puede configurar con las opciones [`--shell`][shell option] y [`--flag`][flag option].
-Su salida es analizada por un [adaptador del arnés de referencia][benchmark harness adapters],
-que se puede establecer usando la opción [`--adapter`][adapter option].
-Sin embargo, si el arnés de referencia genera salida a un archivo, entonces la opción [`--file`][file option]
-también debe usarse para especificar la ruta del archivo de salida.
-Alternativamente, para rastrear el tamaño del archivo de salida (es decir, tamaño binario) en lugar de su contenido,
+## Comando de benchmark
+
+El primer argumento de `bencher run` es el comando de benchmark opcional.
+Este es el comando que se ejecutará para invocar tu harness de benchmark.
+También puede establecerse mediante la variable de entorno `BENCHER_CMD`.
+Por defecto este comando se ejecuta en un shell,
+el cual puede configurarse con las opciones [`--shell`][shell option] y [`--flag`][flag option].
+Su salida es analizada por un [benchmark harness adapter][benchmark harness adapters],
+que puede establecerse usando la opción [`--adapter`][adapter option].
+Sin embargo, si el harness de benchmark escribe en un archivo entonces también debe usarse la opción [`--file`][file option]
+para especificar la ruta del archivo de salida.
+Alternativamente, para rastrear el tamaño del archivo de salida (por ejemplo, el tamaño del binario) en lugar de su contenido,
 usa la opción [`--file-size`][file size option] para especificar la ruta del archivo de salida.
 
-Si prefieres que el comando no se ejecute en una shell, puedes usar la bandera `--exec` o simplemente proporcionar argumentos adicionales a tu comando como argumentos adicionales a `bencher run`.
+Si prefieres que el comando no se ejecute en un shell, puedes usar la bandera `--exec` o simplemente proporcionar argumentos adicionales a tu comando como argumentos adicionales a `bencher run`.
 
 Forma Shell:
 <ShellForm />
 
 Forma Exec:
 <ExecForm />
 
-El comando de benchmark se puede ejecutar múltiples veces usando la opción [`--iter`][iter option],
-y esos resultados pueden ser combinados en un solo resultado usando la opción [`--fold`][fold option].
+El comando de benchmark puede ejecutarse múltiples veces usando la opción [`--iter`][iter option],
+y esos resultados pueden combinarse en un único resultado usando la opción [`--fold`][fold option].
 Si alguna de las iteraciones falla, entonces se considera que todo el comando ha fallado
-a menos que la bandera [`--allow-failure`][allow failure flag] esté establecida.
-
-Si el comando de benchmark no se especifica pero la opción [`--file`][file option] sí,
-entonces `bencher run` simplemente leerá de la ruta del archivo de salida en su lugar.
-De manera similar, si el comando de benchmark no se especifica pero la opción [`--file-size`][file size option] sí,
-entonces `bencher run` simplemente leerá el tamaño del archivo en la ruta de archivo dada en su lugar.
-Si ni el comando de benchmark, la opción [`--file`][file option],
-ni la opción [`--file-size`][file size option] están especificados,
-entonces `bencher run` leerá desde `stdin` en su lugar.
-Esto te permite guardar la salida de otro comando en un archivo o canalizarlo a `bencher run`.
+a menos que se haya establecido la bandera [`--allow-failure`][allow failure flag].
+
+Si no se especifica el comando de benchmark pero sí la opción [`--file`][file option],
+entonces `bencher run` simplemente leerá desde la ruta del archivo de salida.
+De forma similar, si no se especifica el comando de benchmark pero sí la opción [`--file-size`][file size option],
+entonces `bencher run` simplemente leerá el tamaño del archivo en la ruta indicada.
+Las opciones `--file` y `--file-size` pueden especificarse varias veces para leer desde múltiples archivos.
+
+<blockquote>
+<details>
+  <summary>🐰 Consejos para usar la opción <code>-&#8288;-file</code></summary>
+  La opción <code>-&#8288;-file</code> se puede usar para leer resultados de benchmark desde un archivo.
+  Puedes especificar la opción <code>-&#8288;-file</code> varias veces para leer desde múltiples archivos.
+  Si especificas la opción <code>-&#8288;-file</code> varias veces,
+  entonces cada archivo se considerará una <code>iteración</code> separada del comando de benchmark.
+  Cuando se muestren, estos resultados aparecerán en tablas separadas.
+
+  Si deseas combinar estos resultados en una sola <code>iteración</code>,
+  puedes establecer la opción <code>-&#8288;-iter</code> en <code>1</code>
+  y establecer la opción <code>-&#8288;-fold</code> en una de las funciones de agregación <code>min</code>, <code>max</code> o <code>median</code>.
+  Esto plegará los resultados en una sola <code>iteración</code>
+  y los mostrará en una única tabla.
+  No establezcas la opción <code>-&#8288;-fold</code> en <code>mean</code>.
+</details>
+</blockquote>
+
+Si no se especifican ni el comando de benchmark, ni la opción [`--file`][file option],
+ni la opción [`--file-size`][file size option],
+entonces `bencher run` leerá desde `stdin`.
+Esto te permite guardar la salida de otro comando en un archivo o encadenarla (pipe) a `bencher run`.
 
 [benchmark harness adapters]: /es/docs/explanation/adapters/