Ubuntu Manpage: likwid-bench - low-level benchmark suite and microbenchmarking framework

NAME

       likwid-bench - low-level benchmark suite and microbenchmarking framework

SYNOPSIS

       likwid-bench  [-hap]  [-l  <testname>]  [-i  <iterations>] [-g <number_of_workgroups>] [-t
       <testname>] [-w <workgroup_expression>]

DESCRIPTION

       likwid-bench  is  a  benchmark  suite  for  low-level  (assembly)  benchmarks  to  measure
       bandwidths  and  instruction  throughput for specific instruction code on x86 systems. The
       currently included benchmark codes include common data access patterns like load and store
       but  also  calculations  like  vector  triad  and sum.  likwid-bench includes architecture
       specific benchmarks for  x86,  x86_64  and  x86  for  Intel  Xeon  Phi  coprocessors.  The
       performance  values can either be calculated by likwid-bench or measured using performance
       counters by using.  likwid-perfctr as a wrapper to likwid-bench.  This requires  to  build
       likwid-bench.  with Instrumentation which can be enabled in config.mk.

OPTIONS

       -h     prints a help message to standard output, then exits.

       -a     list available benchmark codes for the current system.

       -p     list available thread domains.

       -l  <testname>
              list properties of a benchmark code.

       -i  <iterations>
              number of iterations to perform inside the benchmark code.

       -t  <testname>
              Name of the benchmark code to run (mandatory).

       -g  <number_of_workgroups>
              specify the number of workgroups to perform the benchmark code on (mandatory).

       -w  <workgroup_expression>
              Specify  the  affinity  domain,  thread  count  and  data  set size for the current
              benchmarking run (mandatory).

WORKGROUP SYNTAX

       <thread_domain>:<size> [:<num_threads>[:<chunk_size>:<stride>]]  [-<streamId>:<domain_id>]
       with  size  in  kB, MB or GB. Where thread domain is where threads are placed. Size is the
       total data set size for the benchmark. num_threads specifies how many  threads  are  used.
       Threads  are  always  placed  using a compact policy in likwid-bench.  This means that per
       default all SMT threads are used. Optionally similar a  the  expression  based  syntax  in
       likwid-pin  a  chunk  size  and  stride can be provided. Optionally for every stream means
       array the placement can be controlled. Per default all  arrays  are  placed  in  the  same
       thread  domain  the  threads  are  running in. To place the data in a different domain for
       every stream of a benchmark case (the total number of streams  can be aquired  by  the  -l
       option)  the  domain  to  place  the  data in can be specified. Multiple streams are comma
       separated. Either the placement is provided or all streams have to be  explicitly  placed.
       Please  refer  to  the  Wiki pages on http://code.google.com/p/likwid/wiki/LikwidBench for
       further details and examples on usage.

EXAMPLE

1. Run the copy benchmark with 1000 iterations on socket 0 with a total data set size of
100kB.

likwid-bench -t copy -i 1000 -g 1 -w S0:100kB

Since no num_thread is given in the workload expression, each core of socket 0 gets one
thread. The workload is split up between all threads.

2. Run the triad benchmark code with 100 iterations with 2 threads on the socket 0 and a
data size of 1 GB.

likwid-bench -t triad -i 100 -g 1 -w S0:1GB:2:1:2

Assuming socket 0 has 4 SMT threads, one thread is assigned to each physical core of
socket 0.

3. Run the update benchmark with 1000 iterations on socket 0 with a workload of 100kB and
on socket 1 with the same workload.

likwid-bench -t update -i 1000 -g 2 -w S0:100kB -w S1:100kB

The results of both workgroups are combinded for the output. Hence the workload in each
workgroup expression should have the same size.

4. Run the copy benchmark but measure the memory traffic with likwid-perfctr. The option
INSTRUMENT_BENCH in config.mk needs to be true at compile time to use that feature.

likwid-perfctr -C E:S0:4 -g MEM -m likwid-bench -t update -i 1000 -g 1 -w S0:100kB

likwid-perfctr will configure and start the performance counters on socket 0 with 4
threads prior to the execution of likwid-bench. The performance counters are read right
before and after running the benchmarking code to minimize the interferences of the
measurement.

5. Run the copy benchmark and place the data on other socket

likwid-bench -t copy -i 50 -g 1 -w S0:1GB:10:1:2-0:S1,1:S1

Stream id 0 and 1 are placed in thread domains S1, which is socket 1. This can be verified
as the initialization threads output where they are running.

AUTHOR

       Written by Jan Treibig <jan.treibig@gmail.com>.

BUGS

       Report Bugs on <http://code.google.com/p/likwid/issues/list>.