Provided by: rt-tests_0.93-1ubuntu1_i386 bug


       hackbench - scheduler benchmark/stress test


       hackbench  [-p|--pipe] [-s|--datasize <bytes>] [-l|--loops <num-loops>]
       [-g|--groups   <num-groups>]   [-f|--fds   <num-fds>]    [-T|--threads]
       [-P|--process] [--help]


       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.

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

       -s, --datasize=<size in bytes>
              Sets the amount of data to send in each message

       -l, --loops=<number of loops>
              How many messages each sender/receiver pair should send

       -g, --groups=<number of groups>
              Defines how many groups  of  senders  and  receivers  should  be

       -f, --fds=<number of file descriptors>
              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.

       -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

       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

       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.

                              February  23, 2010                  hackbench(8)