README file for unixperf

7/11/95 ------------------------------------------------------------

unixperf is a synthetic, primitive level O/S benchmark similar in
output to x11perf.

The philosophy of unixperf is the following:

  o  Each tests should take a short amount of time to run.  On the
     order of less than 1/2 minute.

  o  The tests should be deterministic in their results.

  o  Running unixperf should require no special setup.  It should
     require no data files or other host setup.  You should be able to
     copy the unixperf executable onto a machine and just run it.

  o  A warm-up cycle is run before the real results are taken both
     to ensure the tested operation is "warm" and to estimate the
     number of operations to run per test cycle to achieve a
     reasonable testing time.

  o  The results are reported in operations/second (bigger is better).

Examples:

  o  Run through all the tests:

       unixperf -all

  o  Run through all the tests, only repeating each test twice and
     trying to keep each run about 3 seconds long:

       unixperf -all -repeat 2 -time 3

  o  Run three individual tests:

       unixperf -openclose -qsort16k -devzerowalk

  o  Run all tests, redirecting output to a file, but tracking progress
     on stderr:

       unixperf -progress -all > beta1.results

  o  Compare runs from two unixperf runs:

       /usr/bin/X11/x11perfcomp -r beta1.results mr.results

     NOTE: x11perfcomp is found in x_eoe.sw.Xgifts which is not install
     by default.

Current tests:

usage: unixperf [-options ...]
where options include:
    -repeat <n>          do tests <n> times (default = 5)
    -time <s>            do tests for ~<s> seconds each (default = 5)
    -progress            report progress to stderr
    -all                 do all tests
    -dmatrixmult         4 by 4 double matrix multiply
    -fmatrixmult         4 by 4 float matrix multiply
    -deeprecursion       recurse 250 simple function calls and return
    -bcopy256            bcopy of 256 bytes
    -bcopy16k            bcopy of 16 kilobytes
    -bcopy1meg           bcopy of 1 megabyte
    -qsort400            bcopy then qsort 400 32-bit integers
    -qsort16k            bcopy then qsort 16,000 32-bit integers
    -qsort64k            bcopy then qsort 64,000 32-bit integers
    -ftrig               basic float trigonometric function (sinf/cosf/tanf)
    -dtrig               basic double trigonometric function (sin/cos/tan)
    -dhrystone           Dhrystone 2 (from Byte Unix benchmark)
    -hanoi10             Tower of Hanoi recursion test (10 deep)
    -hanoi15             Tower of Hanoi recursion test (15 deep)
    -writelog            write 80 bytes to a log file
    -createunlink        per-file cost of creating 100 files then unlinking them all
    -openclose           per-file cost of open and immediate close of 100 files
    -chmod               per-chmod cost of chmod permissions toggle of 100 files
    -statdir             open directory and stat 100 files in it
    -mkdirrmdir          per-dir cost of making 100 dirs then rmdiring them all
    -dbmlookup           ndbm lookup into database with 900 entries
    -pipeping1           1 byte token passing between two processes using two pipes
    -pipeping1k          1 kilobyte token passing between two processes using two pipes
    -tcpecho             server echoes byte using local TCP during TIME WAIT backlog
    -tcpspawn            server spawns child to echo byte using local TCP during TIME WAIT backlog
    -getpid              getpid system call
    -ezsyscalls          easy system calls: dup/close/getpid/getuid/umask
    -gettimeofday        gettimeofday system call
    -forkwait            fork, child immediately exits, parent waits
    -sleep1              sleep for one second (validates test time)
    -select0             select on no fds with no timeout
    -select16r           select on 16 pipe read fds with immediate timeout
    -select32r           select on 32 pipe read fds with immediate timeout
    -select16w           select on 16 pipe write fds with immediate timeout
    -select32w           select on 32 pipe write fds with immediate timeout
    -select64rw          select on 64 pipe read & 64 pipe write fds with immediate timeout
    -popenecho           popen and read from "/bin/echo hello"
    -devzeromap          mmap megabyte /dev/zero region 
    -devzerowalk         touch newly mmaped megabyte /dev/zero region at every 1024 bytes
    -mmapmegfile         copy every byte of newly mmaped megabyte file
    -compress            compress & uncompress 52 kilobyte text file of numbers
    -compile             compile ANSI C `hello world' with no special options
    -bcopy               alias for -bcopy256 -bcopy16k -bcopy1meg
    -qsort               alias for -qsort400 -qsort16k -qsort64k
    -trig                alias for -ftrig -dtrig
    -tcp                 alias for -tcpecho -tcpspawn
    -pipe                alias for -pipeping1 -pipeping1k
    -devzero             alias for -devzeromap -devzerowalk
    -select              alias for -select0 -select16r -select32r -select16w -select32w -select64rw
    -recurse             alias for -deeprecursion -hanoi10 -hanoi15

- Mark Kilgard
