Provided by: rt-tests_2.2-1_amd64 bug


       hackbench - scheduler benchmark/stress test


       hackbench  [-f|--fds  NUM]  [-F|--fifo]  [-g|--groups  NUM] [-h|--help] [-l|--loops LOOPS]
       [-p|--pipe] [-s|--datasize SIZE] [-T|--threads] [-P|--process]


       Hackbench is both a benchmark and a stress test for the Linux kernel scheduler. It's  main
       job  is  to  create a specified number of pairs of schedulable entities (either threads or
       traditional processes) which communicate via either sockets or pipes and time how long  it
       takes for each pair to send data back and forth.


       These  programs  follow the usual GNU command line syntax, with long options starting with
       two dashes ("--").
       A summary of options is included below.

       -f, --fds=NUM
              Defines how many file descriptors each child should use.  Note that  the  effective
              number  will  be twice the amount you set here, as the sender and receiver children
              will each open the given amount of file descriptors.

              Change the main thread to SCHED_FIFO  after  creating  workers.   This  allows  the
              management thread to run after many workers are created.

       -g, --groups=NUM
              Defines how many groups of senders and receivers should be started

       -h, --help

       -l, --loops=LOOPS
              How many messages each sender/receiver pair should send

       -p, --pipe
              Sends the data via a pipe instead of the socket (default)

       -s, --datasize=SIZE
              Sets the amount of data to send in each message

       -T, --threads
              Each sender/receiver child will be a POSIX thread of the parent.

       -P, --process
              Hackbench will use fork() on all children (default behaviour)
              Shows a simple help screen


       Running  hackbench  without  any  options  will  give  default behaviour, using fork() and
       sending data between senders and receivers via sockets.

       user@host: ~ $ hackbench
       Running in process mode with 10 groups using 40 file descriptors each (== 400 tasks)
       Each sender will pass 100 messages of 100 bytes
       Time: 0.890

       To use pipes between senders and receivers and using threads instead of fork(), run

       user@host: ~ $ hackbench --pipe --threads   (or hackbench -p -T)
       Running in threaded mode with 10 groups using 40 file descriptors each (== 400 tasks)
       Each sender will pass 100 messages of 100 bytes
       Time: 0.497

       Set the datasize to 512 bytes, do 200 messages per sender/receiver pairs and use 15 groups
       using 25 file descriptors per child, in process mode.

       user@host: ~ $ hackbench -s 512 -l 200 -g 15 -f 25 -P
       Running in process mode with 15 groups using 50 file descriptors each (== 750 tasks)
       Each sender will pass 200 messages of 512 bytes
       Time: 4.497


       hackbench  was  written  by  Rusty Russell <> with contributions from
       Yanmin  Zhang  <>,  Ingo  Molnar  <>  and   David
       Sommerseth <>

       This  manual page was written by Clark Williams <> and David Sommerseth


       This   version   of    hackbench    is    based    on    the    code    downloaded    from   Yanmin  Zhang merged the
       original hackbench code from    which    uses
       fork() and a modified version from  which  uses pthread only and
       gave the possibility to change behaviour at run time.   Hackbench  have  since  then  gone
       through  some  more  rewriting  to  improve error handling and proper tracking of fork()ed
       children, to avoid leaving zombies on the system if hackbench stops unexpectedly.

                                       September  19, 2020                           hackbench(8)