/usr/bin/llvm-exegesis

OVERVIEW: llvm host machine instruction characteristics measurment and analysis.

USAGE: llvm-exegesis [options]

OPTIONS:

Generic Options:

  --help                                          - Display available options (--help-hidden for more)
  --help-list                                     - Display list of available options (--help-list-hidden for more)
  --version                                       - Display the version of this program

llvm-exegesis analysis options:

  --analysis-clustering=<value>                   - the clustering algorithm to use
    =dbscan                                       -   use DBSCAN/OPTICS algorithm
    =naive                                        -   one cluster per opcode
  --analysis-clustering-epsilon=<number>          - epsilon for benchmark point clustering
  --analysis-clusters-output-file=<string>        -
  --analysis-display-unstable-clusters            - if there is more than one benchmark for an opcode, said benchmarks may end up not being clustered into the same cluster if the measured performance characteristics are different. by default all such opcodes are filtered out. this flag will instead show only such unstable opcodes
  --analysis-inconsistencies-output-file=<string> -
  --analysis-inconsistency-epsilon=<number>       - epsilon for detection of when the cluster is different from the LLVM schedule profile values
  --analysis-numpoints=<uint>                     - minimum number of points in an analysis cluster (dbscan only)
  --analysis-override-benchmark-triple-and-cpu    - By default, we analyze the benchmarks for the triple/CPU they were measured for, but if you want to analyze them for some other combination (specified via -mtriple/-mcpu), you can pass this flag.

llvm-exegesis benchmark options:

  --analysis-filter=<value>                       - Filter the benchmarks before analysing them
    =all                                          -   Keep all benchmarks (default)
    =reg-only                                     -   Keep only those benchmarks that do *NOT* involve memory
    =mem-only                                     -   Keep only the benchmarks that *DO* involve memory
  --benchmark-phase=<value>                       - it is possible to stop the benchmarking process after some phase
    =prepare-snippet                              -   Only generate the minimal instruction sequence
    =prepare-and-assemble-snippet                 -   Same as prepare-snippet, but also dumps an excerpt of the sequence (hex encoded)
    =assemble-measured-code                       -   Same as prepare-and-assemble-snippet, but also creates the full sequence that can be dumped to a file using --dump-object-to-disk
    =measure                                      -   Same as prepare-measured-code, but also runs the measurement (default)
  --benchmark-process-cpu=<int>                   - The CPU number that the benchmarking process should executon on
  --benchmark-repeat-count=<uint>                 - The number of times to repeat measurements on the benchmark k before aggregating the results
  --dump-object-to-disk[=<string>]                  - dumps the generated benchmark object to disk and prints a message to access it
  --execution-mode=<value>                        - Selects the execution mode to use for running snippets
    =inprocess                                    -   Executes the snippets within the same process
    =subprocess                                   -   Spawns a subprocess for each snippet execution, allows for the use of memory annotations
  --ignore-invalid-sched-class                    - ignore instructions that do not define a sched class
  --loop-body-size=<uint>                         - when repeating the instruction snippet by looping over it, duplicate the snippet until the loop body contains at least this many instruction
  --max-configs-per-opcode=<uint>                 - allow to snippet generator to generate at most that many configs
  --measurements-print-progress                   - Produce progress indicator when performing measurements
  --min-instructions=<uint>                       - The minimum number of instructions that should be included in the snippet
  --opcode-index=<int>                            - opcode to measure, by index, or -1 to measure all opcodes
  --opcode-name=<string>                          - comma-separated list of opcodes to measure, by name
  --repetition-mode=<value>                       - how to repeat the instruction snippet
    =duplicate                                    -   Duplicate the snippet
    =loop                                         -   Loop over the snippet
    =min                                          -   All of the above and take the minimum of measurements
    =middle-half-duplicate                        -   Middle half duplicate mode
    =middle-half-loop                             -   Middle half loop mode
  --result-aggregation-mode=<value>               - How to aggregate multi-values result
    =min                                          -   Keep min reading
    =max                                          -   Keep max reading
    =mean                                         -   Compute mean of all readings
    =min-variance                                 -   Keep readings set with min-variance
  --snippets-file=<string>                        - code snippets to measure
  --use-dummy-perf-counters                       - Do not read real performance counters, use dummy values (for testing)
  --validation-counter=<value>                    - The name of a validation counter to run concurrently with the main counter to validate benchmarking assumptions
    =instructions-retired                         -   Count retired instructions
    =l1d-cache-load-misses                        -   Count L1D load cache misses
    =l1d-cache-store-misses                       -   Count L1D store cache misses
    =l1i-cache-load-misses                        -   Count L1I load cache misses
    =data-tlb-load-misses                         -   Count DTLB load misses
    =data-tlb-store-misses                        -   Count DTLB store misses
    =instruction-tlb-load-misses                  -   Count ITLB load misses
    =branch-prediction-misses                     -   Branch prediction misses
  --x86-disable-upper-sse-registers               - Disable XMM8-XMM15 register usage
  --x86-lbr-sample-period=<uint>                  - The sample period (nbranches/sample), used for LBR sampling

llvm-exegesis options:

  --benchmarks-file=<string>                      - File to read (analysis mode) or write (latency/uops/inverse_throughput modes) benchmark results. “-” uses stdin/stdout.
  --mattr=<+feature1,-feature2,...>               - comma-separated list of target architecture features
  --mcpu=<cpu-name>                               - Target a specific cpu type (-mcpu=help for details)
  --mode=<value>                                  - the mode to run
    =latency                                      -   Instruction Latency
    =inverse_throughput                           -   Instruction Inverse Throughput
    =uops                                         -   Uop Decomposition
    =analysis                                     -   Analysis
  --mtriple=<string>                              - Target triple. See -version for available targets