NAME

       hyperfine - hyperfine

DESCRIPTION

       hyperfine 1.12.0 A command-line benchmarking tool.

   USAGE:
              hyperfine [OPTIONS] <command>...

   OPTIONS:

       -w, --warmup <NUM>

              Perform  NUM  warmup  runs before the actual benchmark. This can be used to fill (disk) caches for
              I/O-heavy programs.

       -m, --min-runs <NUM>

              Perform at least NUM runs for each command (default: 10).

       -M, --max-runs <NUM>

              Perform at most NUM runs for each command. By default, there is no limit.

       -r, --runs <NUM>

              Perform  exactly  NUM  runs  for  each  command.  If  this  option  is  not  specified,  hyperfine
              automatically determines the number of runs.

       -p, --prepare <CMD>...

              Execute  CMD  before  each  timing run. This is useful for clearing disk caches, for example.  The
              --prepare option can be specified once for all commands or multiple times, once for each  command.
              In  the  latter  case,  each  preparation command will be run prior to the corresponding benchmark
              command.

       -c, --cleanup <CMD>

              Execute CMD after the completion of all benchmarking  runs  for  each  individual  command  to  be
              benchmarked.  This  is  useful if the commands to be benchmarked produce artifacts that need to be
              cleaned up.

       -P, --parameter-scan <VAR> <MIN> <MAX>

              Perform benchmark runs for each value in the range MIN..MAX. Replaces the string '{VAR}'  in  each
              command by the current parameter value.

       Example:
              hyperfine -P threads 1 8 'make -j {threads}'

              This performs benchmarks for 'make -j 1', 'make -j 2', ???, 'make -j 8'.

              To have the value increase following different patterns, use shell arithmetics.

              Example: hyperfine -P size 0 3 'sleep $((2**{size}))'

              This  performs  benchmarks  with  power  of 2 increases: 'sleep 1', 'sleep 2', 'sleep 4', ???  The
              exact syntax may vary depending on your shell and OS.

       -D, --parameter-step-size <DELTA>

              This argument requires --parameter-scan to be specified as well. Traverse the  range  MIN..MAX  in
              steps of DELTA.

       Example:
              hyperfine -P delay 0.3 0.7 -D 0.2 'sleep {delay}'

              This performs benchmarks for 'sleep 0.3', 'sleep 0.5' and 'sleep 0.7'.

       -L, --parameter-list <VAR> <VALUES>

              Perform  benchmark  runs  for  each value in the comma-separated list VALUES.  Replaces the string
              '{VAR}' in each command by the current parameter value.

       Example:
              hyperfine -L compiler gcc,clang '{compiler} -O2 main.cpp'

              This performs benchmarks for 'gcc -O2 main.cpp' and 'clang -O2 main.cpp'.

              The option can  be  specified  multiple  times  to  run  benchmarks  for  all  possible  parameter
              combinations.

       -s, --style <TYPE>

              Set  output  style  type  (default:  auto).  Set  this  to  'basic' to disable output coloring and
              interactive elements. Set it to 'full' to enable all effects even if no interactive  terminal  was
              detected.  Set  this  to  'nocolor' to keep the interactive output without any colors. Set this to
              'color' to keep the colors without any interactive output. Set this to 'none' to disable  all  the
              output of the tool.

       -S, --shell <SHELL>

              Set the shell to use for executing benchmarked commands.

       -i, --ignore-failure

              Ignore non-zero exit codes of the benchmarked programs.

       -u, --time-unit <UNIT>

              Set the time unit to be used. Possible values: millisecond, second.

       --export-asciidoc <FILE>

              Export the timing summary statistics as an AsciiDoc table to the given FILE.

       --export-csv <FILE>

              Export  the timing summary statistics as CSV to the given FILE. If you need the timing results for
              each individual run, use the JSON export format.

       --export-json <FILE>

              Export the timing summary statistics and timings of individual runs as JSON to the given FILE.

       --export-markdown <FILE>

              Export the timing summary statistics as a Markdown table to the given FILE.

       --show-output

              Print the stdout and stderr of the benchmark instead of suppressing it.  This  will  increase  the
              time  it  takes  for  benchmarks  to run, so it should only be used for debugging purposes or when
              trying to benchmark output speed.

       -n, --command-name <NAME>...

              Give a meaningful name to a command

       -h, --help

              Print this help message.

       -V, --version

              Show version information.

   ARGS:
              <command>...

              Command to benchmark

hyperfine 1.12.0                                   August 2022                                      HYPERFINE(1)