sources-request@munnari.oz (01/24/88)
Submitted by: kenj@moncsbruce.oz (Ken McDonell)
Posting-number: Volume 12, Issue 74
Archive-name: musbus5.2/Part03
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
# update.033
# update.034
# update.035
# update.036
# update.037
# update.038
# update.039
# update.040
# update.041
# update.042
# update.043
# update.044
# update.045
# update.046
# update.047
# update.048
# This archive created: Tue Jan 19 08:37:27 EST 1988
export PATH; PATH=/bin:$PATH
echo 'x - update.033'
if test -f 'update.033'
then
echo 'shar: over-writing existing file update.033'
fi
sed 's/^X//' > update.033 <<'End-of-File-Grunt'
X.\"##########
X.\"# Big troff text file for workload scripts
X.\"##########
X.nr Pw 6.75i
X.nr Po 0i
X.ll \n(Pwu
X.ev 2
X.ll \n(Pwu
X.lt \n(Pwu
X.ev
X.po -\n(Po
X.hy 14
X.nr II 0
X.de SZ
X.ps \\$1
X.vs \\$1u*1.25p
X..
X.de NH
X.in 0
X.if t .sp 0.5v
X.if n .sp
X.ne 6v
X.SZ 12
X.ft B
X\\$1 \\$2
X.br
X.ft P
X.SZ 10
X..
X.de LP
X.in \\n(IIu
X.if t .sp 0.35v
X.if n .sp
X.ne 3v
X..
X.de IP
X.LP
X.in +4n
X.ta 4n
X.ti -4n
X\\$1 \\c
X..
X.de PR
X\\fI\\$1\\fP\\$2
X..
X.de FL
X\\fB\\$1\\fP\\$2
X..
X.de SC
X.ti +6n
X.if t .HS
X$ \\$1
X.br
X.if t .HE
X..
X.de SV
X\\fI$\\$1\\fP\\$2
X..
X.de RS
X.in +6n
X..
X.de RE
X.in -6n
X..
X.de HS
X.ft H
X.ps -1
X..
X.de HE
X.ps +1
X.ft P
X..
X.de VA
X.IP "\fIShell Variable:\fP \\fB\\$1\\fP (default: \\$2)"
X.br
X..
X.de TN
X.IP "\fITest Name:\fP \\fB\\$1\\fP"
X.br
X..
X\&
X.sp 1i
X.de Fo
X'Hd
X..
X.de Hd
X.ev 2
X.bp
X.in 0
X.sp
X.tl 'MUSBUS Introduction''%.'
X.sp
X.ev
X..
X.wh -0.1i Fo
X.ad c
X.SZ 14
X.ft B
XAn Introduction to the Monash Benchmark Suite (MUSBUS)
X.if t .sp 0.5v
X.if n .sp
X.SZ 12
X.ft I
XKen J. McDonell
X.if t .sp 0.5v
X.if n .sp
X.SZ 10
X.ft R
XDepartment of Computer Science
X.br
XMonash University
X.br
XClayton, AUSTRALIA 3168
X.sp
XACSnet: kenj@moncskermit.oz
X.br
XUSENET: seismo!munnari!moncskermit.oz!kenj
X.br
XARPA: kenj%moncskermit.oz@seismo.arpa
X.sp
XRevised: 24 June, 1987
X.br
X.ad b
X.NH 1 Introduction
X.LP
XThe Monash University Suite for Benchmarking
XUNIX\v'-.5n'\(dg\v'+.5n'
X.de DF
X'FN
X.rm DF
X..
X.wh -0.7i DF
X.de FN
X.ev 2
X.in 0
X.sp
X\\l'1.5i\(ul'
X.sp 0.5v
X\v'-.5n'\(dg\v'+.5n' UNIX is a trademark of AT&T
X.sp 2
X.ev
X.rm FN
X.ch DF -0.01i
X..
XSystems (MUSBUS), has been developed
Xto assist in
X.IP (a)
Xidentifying bottlenecks and performance problems in new
XUNIX ports, and
X.IP (b)
Xproviding a robust test environment in which
Xthe performance of competing
XUNIX systems may be compared.
X.LP
XThis document provides an overview for \fBVersion\fP \fB5.0 (Beta)\fP of MUSBUS
Xand is intended for knowledgeable programmers trying to run
Xthe software on their own hardware.
X.NH 2 Preliminaries
X.NH 2.1 "Software Environment"
X.LP
XYou will require a system that supports Level 7, System V
Xor BSD
Xcompatibility, along with the following programs.
X.RS
X.PR sh
X(the Bourne shell)
X.br
X.PR awk
X.PR cat
X.PR cc
X.PR chmod
X.PR comm
X.PR cp
X.PR date
X.PR dc
X.PR df
X.PR echo
X.PR ed
X.PR expr
X.PR kill
X.PR ls
X.PR make
X.PR mkdir
X.PR rm
X.PR sed
X.PR test
X.PR time
X.PR touch
X.PR tty
X.PR who
X.RE
X.NH 2.2 "Getting Started"
X.LP
XAll the files are distributed in a single directory.
XOnce these have been retrieved from the distribution some initial housekeeping
Xand system specifics have to be sorted out.
X.LP
XWhen fully installed, MUSBUS contains files in several subdirectories
Xas follows,
X.IP \(bu
X.FL Results ,
Xlog files created by the command procedure
X.PR run .
X.IP \(bu
X.FL Tmp ,
Xtemporary files created by
X.PR run
Xand friends.
X.IP \(bu
X.FL Tools ,
Xpost processors to produce
X.PR tbl
Xinput from the log files.
X.IP \(bu
X.FL Workload ,
Xdescriptions of the workload profile, all associated data files and some
Xwork script manipulation tools.
X.LP
XTo explicitly
Xcreate these directories and distribute the required files into the
Xappropriate places you may
X.SC "make install"
Xhowever this will be done automatically by
X.PR run
Xas required.
X.LP
XThe file
X.FL time.awk
Xis used by the command procedure
X.PR run
Xto average the
Xresults from several attempts to time a particular test and so
Xdepends upon the format of output from
X.PR /bin/time .
XThe results from multiple timing attempts are held temporarily
Xin the file
X.FL Tmp/tmp.$$
X(where $$ is the pid of the
X.PR run
Xshell).
XTry
X.SC "/bin/time date"
Xand check the output from
X.PR /bin/time .
XIf it has a format like
X.ti +4n
X0.4 real 0.0 user 0.1 sys
X.br
Xthen
X.SC "rm -f time.awk"
X.SC "ln BSDtime.awk time.awk"
X.LP
XIf the
X.PR /bin/time
Xoutput looks like
X.RS
X.ta 8n
X.nf
Xreal 0:00.4
Xuser 0:00.0
Xsys 0:00.1
X.fi
X.RE
Xthen
X.SC "rm -f time.awk"
X.SC "ln SysVtime.awk time.awk"
X.LP
XOtherwise create your own version of
X.FL time.awk
Xusing
X.FL *time.awk
Xas examples.
X.LP
XSome of the tests require system calls from the C code to measure
Xsmall elapsed times.
XThis is a real problem since there appears to be no
Xuniversally correct way of doing this in the Unix
Xworld.
XThe particular source files are
X.FL clock.c ,
X.FL fstime.c
Xand
X.FL mem.c .
XIn the
X.FL Makefile ,
Xensure that you have \fBone\fP of the following
Xdefinitions included in the CFLAGS (in addition to the \(miO).
X.RS
X.ta 12n
X.nf
X.if t \fH\s-1\(miDSysV\s+1\fP you are using a System V brand of Unix
X.if n \(miDSysV you are using a System V brand of Unix
X.if t \fH\s-1\(miDBSD4v2\s+1\fP you are using a Berkeley 4.2 or 4.3 system
X.if n \(miDBSD4v2 you are using a Berkeley 4.2 or 4.3 system
X.if t \fH\s-1\(miDBSD4v1\s+1\fP you are using a Berkeley 4.1 system
X.if n \(miDBSD4v1 you are using a Berkeley 4.1 system
X.fi
X.RE
XFor example,
X.ti +6n
X.if t \fH\s-1CFLAGS = \(miO \(miDBSD4v2\s+1\fP
X.if n CFLAGS = -O -DBSD4v2
X.LP
XIf \fBnone\fP of these systems
Xis appropriate, the source files \fIwill not compile\fP
Xand you will have to decide on appropriate alternative calls
Xand coding to suit local conditions.
X.LP
XCheck the
X.FL HISTORY
Xfile (if it exists) for notification of any changes, additions
Xor problems that may have been made or fixed subsequent to the version
Xof MUSBUS described in this document.
X.LP
XTry
X.SC "make programs"
Xto confirm that every necessary program can be compiled and
Xloaded correctly.
X.LP
XNow attempt to run all the tests once (this takes roughly 20 minutes).
XUsing the Bourne shell (\c
X.PR /bin/sh ),
X.SC "iterations=1"
X.SC "nusers=1"
X.SC "export iterations nusers"
X.SC "./run"
X.LP
XThis should demonstrate
Xthat all the
X.PR sh,
X.PR awk,
X.PR sed
Xand
X.PR ed
Xscripts
Xcan be made to work.
XVerification of the health of things to this point depends upon
Xchecking the output from
X.PR run
Xto ensure that no nasty errors
Xare reported, and in particular scrolling through the file
X.FL Results/log .
XEvery time
X.PR run
Xis used information is \f3appended\fP to
X.FL Results/log
Xand
X.FL Results/log.work ,
Xso make sure that these files are removed or renamed before you start
Xto do anything serious.
XThe contents of
X.FL Results/log
Xshould look something like
X.LP
X.RS
X.nf
X.HS
XStart Benchmark Run (MUSBUS Version X.Y)
X Tue Jun 23 17:18:21 EDT 1987 (long iterations 6 times)
X 2 interactive users.
X
XArithmetic Test (type = arithoh): 1000 Iterations
XElapsed Time: 0.44 seconds (variance 0.003)
XCPU Time: 0.30 seconds [ 0.30u + 0.00s ] (variance 0.000)
X
XArithmetic Test (type = register): 1000 Iterations
XElapsed Time: 3.36 seconds (variance 0.008)
XCPU Time: 3.18 seconds [ 3.13u + 0.05s ] (variance 0.008)
X
X[ ... and lots more similar goodies ]
X
XOutput sent to ... /dev/ttyp0
XDirectories for temporary files ... Tmp
X
X.nf
X.ta 14n,+8n,+8n,+8n,+8n
XFilesystem kbytes used avail capacity Mounted on
X/dev/hp0a \07419 \06202 \0\0475 93% /
X/dev/hp0g 38383 33296 \01248 96% /usr
X/dev/hp1a \07419 \04169 \02508 62% /jnk
X/dev/hp1b 15583 \03181 10843 23% /usr/spool
X/dev/hp1g 38383 32579 \01965 94% /mnt
X/dev/up1a \07471 \0\0\010 6713 \00% /tmp
X
XSIGALRM check: 12 x 5 sec delays takes 60.05 wallclock secs (error -0.08%)
XSimulated Multi-user Work Load Test:
X
X1 Concurrent Users, each with Input Keyboard Rate 2 chars / sec
XElapsed Time: 425.83 seconds (variance 0.125)
XCPU Time: 27.20 seconds [ 17.30u + 9.90s ] (variance 0.013)
X
X 1 interactive users.
XEnd Benchmark Run (Wed Jun 24 09:33:55 EDT 1987) ....
X.HE
X.fi
X.RE
X.LP
XBeware of lines with the following formats, they indicate something
Xis \fBwrong\fP.
X.if t .IP "\fH\s-1** Iteration x Failed: text\fP\s+1"
X.if n .IP "** Iteration x Failed: text"
X.br
XSomething (\fItext\fP) other than the normally anticipated output from
X.PR /bin/time
Xwas found in the file
X.FL Tmp/tmp.$$ .
X.if t .IP "\fH\s-1Elapsed Time: -- no measured results!!\fP\s+1";
X.if n .IP "Elapsed Time: -- no measured results!!";
X.br
XNot a single valid timing result was found in
X.FL Tmp/tmp.$$ .
X.if t .IP "\fH\s-1Terminated during iteration n\fP\s+1"
X.if n .IP "Terminated during iteration n"
X.br
XPremature termination of a test, usually as the result of
Xa shell trap taken from
X.PR run .
XMost often this is symptomatic of an earlier
Xerror reported in
X.FL Results/log .
X.if t .IP "\fH\s-1* Apparent errors from makework ... *\fP\s+1"
X.if n .IP "* Apparent errors from makework ... *"
X.br
XAfter cleaning the log files from the multi-user test (using
X.PR sed
Xand the script
X.FL check.sed )
Xsome lines remained that probably indicate
Xreal errors which forced the multi-user test to
Xterminate prematurely.
XDepending upon the formats of messages from programs (especially
Xin the multi-user workload),
X.FL check.sed
Xmay need some local fine tuning to remove lines,
Xthat do not reflect genuine error conditions, from
Xthe log files.
XIf this is not done,
Xthe tests will be aborted prematurely based upon the classification
Xof a spurious message as a real error condition.
X.if t .IP "\fH\s-1Reason?: text\fP\s+1"
X.if n .IP "Reason?: text"
X.br
X.PR Makework
X(the controlling program for the multi-user test)
Xhas detected an inconsistency and taken a fatal dive,
X\fItext\fP comes from
X.PR perror ()
Xand the previous line in
X.FL Results/log
Xwill contain
X.PR makework "'s"
Xidea of what is wrong.
X.if t .IP "\fH\s-1* Benchmark Aborted .... *\fP\s+1"
X.if n .IP "* Benchmark Aborted .... *"
X.br
XJust what it says!
X.LP
XOther possible error reports in
X.FL Results/log
Xrelate to specific tests
Xand are either self explanatory (e.g. missing or illegal program
Xoptions) or described in the Sections below.
X.LP
XThe file
X.FL Results/log.work
Xcontains detailed logging of the multi-user test, and may contain
Xuseful information in the event that this test fails or terminates
Xprematurely.
XBesides logging process ids and file descriptor assignments for each
Xsimulated user's job stream, standard error output is trapped and
Xreported in
X.FL Results/log.work .
X.NH 3 "The Tests"
X.LP
XIf you are serious about the results produced, these tests should
Xbe run on a dedicated system without concurrent activity.
XWhen possible, an idle system in mult-iuser mode is
Xpreferable to a single user system.
X.LP
XAll the tests are controlled by shell variables used within the command
Xprocedure
X.PR run .
XBy setting environment variables of the same name, the default values
Xof the shell variables
Xmay be over-ridden, however if the defaults are consistently wrong for
Xparticular variables it is safer (i.e. less error prone) to modify
Xthe defaults in
X.PR run .
X.LP
X.PR Run
Xdoes its work for the most part silently, logging information to
Xcertain files, and providing a terse summary of the particular test(s)
Xbeing run on the tty from which
X.PR run
Xwas invoked.
X.LP
XA designated test may by run using the command
X.SC "./run thing"
Xwhere \fIthing\fP is one of the test names described in the following
XSections.
XThe commands
X.SC "./run"
Xor
X.SC "./run all"
Xwill run everything.
X.LP
X.PR Run
Xmay be interrupted from the keyboard (SIGINT)
Xif it is started in foreground
Xand after some fooling about it manages to shut things down and clean up files.
X.PR run
Xcreates a
X.PR sh
Xcommand procedure
X.FL Tmp/kill_run
Xthat may be used to shut down a background
X.PR run
Xvia
X.SC "Tmp/kill_run"
X.VA iterations 6
XUnless otherwise stated,
Xthis variable controls the number of times each test is repeated for timing.
XAt the beginning of each iteration, the program
X.FL iamalive
Xwrites the iteration
Xnumber (without newline or carriage return)
Xon standard output.
X.NH 3.1 "Raw Speed Measures"
X.NH 3.1.1 "Specific Arithmetic"
X.LP
XThis family of tests computes the sum of a series of terms
Xsuch that the arithmetic is unbiased towards operator type
X(i.e. equal numbers of additions, subtractions, multiplications
Xand divisions).
XEach major loop in the computation involves summing 100 terms
Xof the series.
X.VA arithloop 1000
XNumber of major loops in the computation.
X.TN arithoh
XDo not compute the series, so measures the overhead in the
Xcomputation.
X.TN register
XArithmetic uses registers.
X.TN short
XArithmetic uses shorts.
X.TN int
XArithmetic uses ints.
X.TN long
XArithmetic uses longs.
X.TN float
XArithmetic uses floats.
X.TN double
XArithmetic uses doubles.
X.LP
XAfter all the arithmetic tests have been performed, the
X.PR sh
Xscript
X.FL Tools/Adjust
Xshould be used with
X.FL Results/log ,
Xi.e.
X.SC "./Tools/Adjust Results/log"
Xto compute the \fBactual\fP
XCPU and elapsed times when the overhead measured by the test
X.PR arithoh
Xis subtracted.
XIt is these times (i.e. \fIminus the startup and loop overhead\fP)
Xthat have been published and circulated amongst MUSBUS users.
XFailure to run the
X.PR Tools/Adjust
Xscript will make the machine
Xyou are testing look comparatively worse
Xthan it really is!
XNote that
X.PR Tools/Adjust
Xwill be run automatically by the log file postprocessors (\c
X.PR Tools/mktbl
Xand
X.PR Tools/mkcomp )
Xif the times have not already been adjusted.
XOnce the adjustment has been made, the relevant portion of
X.FL Results/log
Xshould look something like (note \fBActual\fP times in parentheses),
X.LP
X.RS
X.nf
X.HS
XStart Benchmark Run (MUSBUS Version X.Y)
X Tue Jun 23 17:18:21 EDT 1987 (long iterations 6 times)
X 2 interactive users.
X
XArithmetic Test (type = arithoh): 1000 Iterations
XElapsed Time: 0.44 seconds (variance 0.003)
XCPU Time: 0.30 seconds [ 0.30u + 0.00s ] (variance 0.000)
X
XArithmetic Test (type = register): 1000 Iterations
XElapsed Time: 3.36 seconds (variance 0.008) (Actual: 2.92 )
XCPU Time: 3.18 seconds [ 3.13u + 0.05s ] (variance 0.008) (Actual: 2.88 )
X
X[ ... and lots more similar goodies ]
X
X.HE
X.fi
X.RE
X.NH 3.1.2 "General Purpose Arithmetic"
X.TN dc
XCompute the square root of 2 to 99 decimal places using
X.PR dc .
XThe
X.PR dc
Xinput is in
X.FL dc.dat .
XThis test is due to John Lions (University of New South Wales) who
Xhas suggested it as a good first order measure of raw system speed.
X.NH 3.1.3 Recursion
X.VA ndisk 17
X.TN hanoi
XA recursive solution to the classical Tower of Hanoi problem.
XWork increases as 2**(number of disks).
X.SV ndisk
Xprovides a \fIlist\fP of the number of disks for a
X\fBset\fP of problems, however the default setting is for a singular
Xset.
X.NH 3.1.4 "System Calls, Pipes, Forks, Execs and Context Switches"
X.VA ncall 4000
X.TN syscall
XSit in a hard loop of
X.SV ncall
Xiterations, making 5 system calls
Xper iteration.
XThe system calls (\c
X.PR dup (0),
X.PR close (i),
X.PR getpid (),
X.PR getuid ()
Xand
X.PR umask (i))
Xinvolve little work on the part of the UNIX kernel, so
Xthe test predominantly measures the overhead associated with
Xthe system call mechanism.
X.VA io 2048
X.TN pipe
XOne process (therefore no context switching) that writes and reads
Xa 512 byte block along a pipe
X.SV io
Xtimes.
X.VA children 100
X.TN spawn
XSimply repeat
X.SV children
Xtimes; fork a copy of yourself and wait for
Xthe child process to exit (which it should do immediately).
X.VA nexecl 100
X.TN execl
XPerform
X.SV nexecl
Xexecs using
X.PR execl ().
XThe program to be exec'd has been artificially expanded to a reasonable
Xsize (on a VAX, 11264 text + 2048 data + 24388 bss).
X.VA switch1 500
X.TN context1
XPerform 2 x
X.SV switch1
Xcontext switches, using pipes for synchronization.
XThe test involves 2 processes connected via 2 pipes.
XOne process writes then reads a 4-byte (descending) sequence number, while
Xthe other process reads then writes a sequence number.
XSynchronization is validated at each swap by checking the values of the
Xsequence numbers read and written.
X.NH 3.1.5 "C Compilation and Loading"
X.TN C
XMeasure the time for each of
X.SC "cc -c cctest.c"
X.SC "cc cctest.o"
Xwhere
X.FL cctest.c
Xcontains 124 lines of uninteresting C code (108
Xlines of real code after
X.PR cpp ).
X.NH 3.1.6 "Memory Access Speed"
X.LP
XThese tests try to measure read accesses per real second into an array
Xof integers.
XBecause of inaccuracies in measuring small real times, the
Xresults of this test are subject to large variances and
Xcan not be interpreted with great confidence (e.g. negative
Xand infinite speeds have been observed).
XConsequently, these tests are best considered as a
Xhistorical curiosities from the days when MMUs were bottlenecks on
Xmicroporcessor-based systems, and \fBno\fP real significance should
Xbe attached to the observed times.
X.VA poke 100000
XNumber of array accesses.
X.VA arrays "8 64 512"
XList of array sizes in units of 1024 ints.
X.TN seqmem
XCyclic sequential access pattern, hitting each element of the array
Xin turn.
X.TN randmem
XRandom access patterns -- to give VM systems a chance to do something
Xbetter!
X.NH 3.1.7 "Filesystem Throughput"
X.VA blocks "62 125 250 500"
XA list of file sizes in Kbytes.
X.VA where .
XThe directory in which the files will be created.
XThis test requires at least
X2 x max(\c
X.SV blocks )
XKbytes of free space in the filesystem
Xcontaining
X.SV where .
X.TN fstime
XThis program attempts to measure file write time, file read time and
Xfile copy time.
XIt is assumed that BUFSIZ as defined in <stdio.h> is a good size for
Xphysical i/o, and all i/o is done via direct calls to
X.PR read ()
Xand
X.PR write ().
XThis test is performed (\c
X.SV iterations /2)
Xtimes.
X.LP
XBeware of the \fIwrite\fP time, since this can be influenced by the size
Xof the disk block cache in the kernel.
XBefore the reads are commenced there are a couple of
X.PR sync ()s
Xand a 5 second sleep to try and flush the cache.
XThe times for small files are most sensitive to disk block
Xcaching.
X.LP
XReally the \fIcopy\fP time for the largest file
Xis the best indicator of throughput and reflects
Xthe type of disk activity most commonly generated by compilers, editors,
Xassemblers, etc.
XAlso the rates are measured against elapsed time, so there is some
Xscope for variance however the absolute times are usually long enough
Xto make this effect insignificant \fBprovided\fP
Xthere is no concurrent disk activity on the same spindle!
X.NH 3.2 "Emulated Multi-user Test"
X.VA nusers "1 4 8 16 24 32"
XA list of the number users to be emulated.
X.VA ttys /dev/tty
XA \fBlist\fP of tty devices
Xwhere the simulated tty output is sent -- there is a lot of this, and
Xyou should ensure that these tty lines are operating at the normal
Xbaud rate (e.g. 9600) for the test system.
XIf your CPU console does not use a standard serial multiplexer
X(e.g. a VAX, Pyramid, Gould, DG, etc.), then the tty output
Xshould be directed to \fIsome other\fP tty line(s) that \fBdo\fP use the
Xordinary serial port hardware.
X.VA dirs Tmp
XA \fBlist\fP of directories that will be used to create subdirectories
Xand temporary files to run the
Xuser job streams from.
X.VA rate 2
XUsers are assumed to type at a rate of
X.SV rate
Xcharacters per second.
X.TN work
XOf all the tests in MUSBUS,
Xthis is the by far the most complicated, most realistic and most likely
Xto fail.
XThis test is performed (\c
X.SV iterations /2)
Xtimes.
X.LP
XThe synthetic workload is created from a number of job streams, each
Xof which is described by a line in the file
X.FL Tmp/workload .
XEach line consists of
X.IP \(bu
Xthe home directory for the job stream,
X.IP \(bu
Xthe full pathname of the program to run,
X.IP \(bu
Xoptional arguments to that program,
X.IP \(bu
Xan optional source
Xof standard input to that program (a filename prefixed by ``<''), and
X.IP \(bu
Xan optional destination
Xfor standard output from that program (a filename prefixed by ``>'').
X.LP
X.FL Tmp/workload
Xis created automatically by the command script
X.PR run
Xbased upon
X.IP (a)
Xthe variables
X.SV dirs
Xand
X.SV ttys , and
X.IP (b)
Xthe workload profile
X.FL Workload/script.master
Xfrom which the script interpreter program name is extracted
Xand the individual input script files (\c
X.FL Tmp/script.? ).
X.LP
XWhen
X.FL Tmp/workload
Xis constructed, a cyclic scheme
Xis used to share user work amongst the
Xavailable directories and tty lines (as per
X.SV dirs
Xand
X.SV ttys ).
XIn this way, serial i/o bottlenecks for large numbers of simulated
Xusers, and unbalanced disk i/o across spindles may be avoided.
XAs a dynamic check, the program
X.PR ttychk
Xis used within
X.PR run
Xto check for potential bandwidth limitations on the serial i/o
Xlines, given the number of lines and the maximum number of job streams.
X.LP
XThe workload profile (\c
X.FL Workload/script.master )
Xhas the following format.
X.IP 1.
XThe first line must begin ``%W%'' followed by the full pathname of the
Xrelevant interpreter and any required options.
XFor example, if the script should be run by the Bourne shell, an
Xappropriate specification would be
X.RS
X.HS
X%W% /bin/sh -ie
X.HE
X.RE
X.IP 2.
XAll subsequent lines up to the first line beginning with ``%%''
Xare preamble commands that must appear at the \f3beginning\fP of \f3every\fP
Xscript.
X.IP 3.
XSequences of commands terminated by a line beginning with ``%%''
Xconstitute a job step.
XEach job step is an autonomous piece of work such that once the
Xpreamble has been executed, job steps may be executed in \f3any\fP order.
X.IP 4.
XAny lines following the last ``%%'' line form a postscript
Xthat must appear at the \f3end\fP of \f3every\fP
Xscript.
X.LP
XThe command procedure
X.PR mkscript
Xand the program
X.PR mkperm
Xare used (by
X.PR run )
Xto create several (usually 4) scripts from
X.FL Workload/script/master
Xwith random permutations
Xof the job steps.
XThese scripts reside in
X.FL Tmp/script.?
Xand are assigned in a cyclic manner to create the job streams.
XThe work for \fBeach\fP
Xsimulated user is generated from
X\fBone\fP job stream.
X.LP
XFor example the distributed
X.FL Workload/script.master
Xis
X.LP
X.RS
X.nf
X.if t .HS
X.CK Workload/script.master
X%W% /bin/sh -ie
Xmkdir /tmp/$$ tmp
X%% 1 edit
X\&./keyb edscr1.dat | ed edit.dat
X: .......................................................
X: . This is some filler of about the same .
X: . size as the file edscr1.dat, since the .
X: . emulated input proceeds in parallel, and .
X: . we want the real-time delay to be about right .
X: .......................................................
Xchmod u+w temporary
Xrm temporary
X%% 2 ls
Xls -l
X%% 3 cat
Xcat cat.dat
X%% 4 compile
Xcc -c cctest.c 1>&2
Xrm *.o
X%% 5 edit, compile and link
Xchmod 444 dummy.c
X\&./keyb edscr2.dat | ed dummy.c
X: . more textual and time filler for the second edscript file, edscr2.dat .
Xcc dummy.c 1>&2
Xrm a.* grunt.c
X%% 6 grep
Xgrep '[ ]*nwork' grep.dat
X%% 7 file copying
Xcp *.c edit.dat /tmp/$$
Xcp /tmp/$$/* tmp
X%%
Xrm -rf tmp /tmp/$$
X.if t .HE
X.fi
X.RE
X.LP
XThis generates several job streams one of which (\c
X.FL Tmp/script.1 )
Xcontains,
X.LP
X.RS
X.nf
X.if t .HS
X.CK Tmp/script.1
Xmkdir /tmp/$$ tmp
Xcc -c cctest.c 1>&2
Xrm *.o
X\&./keyb edscr1.dat | ed edit.dat
X: .......................................................
X: . This is some filler of about the same .
X: . size as the file edscr1.dat, since the .
X: . emulated input proceeds in parallel, and .
X: . we want the real-time delay to be about right .
X: .......................................................
Xchmod u+w temporary
Xrm temporary
Xcat cat.dat
Xgrep '[ ]*nwork' grep.dat
Xchmod 444 dummy.c
X\&./keyb edscr2.dat | ed dummy.c
X: . more textual and time filler for the second edscript file, edscr2.dat .
Xcc dummy.c 1>&2
Xrm a.* grunt.c
Xcp *.c edit.dat /tmp/$$
Xcp /tmp/$$/* tmp
Xls -l
Xrm -rf tmp /tmp/$$
X.if t .HE
X.fi
X.RE
X.LP
XGiven the following environment variable assignments,
X.RS
X.nf
Xnusers=8
Xttys=/dev/ttyh0 /dev/ttyh8 /dev/ttyha
Xdirs=Tmp /usr/tmp
X.fi
X.RE
Xthe created workload description file (\c
X.FL Tmp/workload )
Xcontains
X.LP
X.RS
X.nf
X.if t .HS
XTmp/user1 /bin/sh -ie <Tmp/script.1 >/dev/ttyh0
X/usr/tmp/user2 /bin/sh -ie <Tmp/script.2 >/dev/ttyh8
XTmp/user3 /bin/sh -ie <Tmp/script.3 >/dev/ttyha
X/usr/tmp/user4 /bin/sh -ie <Tmp/script.4 >/dev/ttyh0
XTmp/user5 /bin/sh -ie <Tmp/script.1 >/dev/ttyh8
X/usr/tmp/user6 /bin/sh -ie <Tmp/script.2 >/dev/ttyha
XTmp/user7 /bin/sh -ie <Tmp/script.3 >/dev/ttyh0
X/usr/tmp/user8 /bin/sh -ie <Tmp/script.4 >/dev/ttyh8
X.if t .HE
X.fi
X.RE
X.LP
XIt is strongly recommended that you create your own workload
Xprofile for the multi-user test to reflect the anticipated
Xsystem usage.
XTo do this,
X.IP 1.
XUse the distributed files in the
X.FL Workload
Xdirectory as a guide.
X.IP 2.
XCreate a new
X.FL Workload/script.master
Xdescribing the required job steps.
X.IP 3.
XEnsure all required data files are in the
X.FL Workload
Xdirectory, because every job stream executes with the current
Xdirectory containing its own private copies of \f3all\fP the
Xfiles from
X.FL Workload .
X.IP 4.
XEnsure the makefile (\c
X.FL Workload/Makefile )
Xhas the following targets defined (they are assumed to exist by
X.PR run ).
X.RS
X.nr II 6n
X.IP (a)
Xcontext : ensure all files needed to run a script are present.
X.IP (b)
Xclean : remove any unnecessary temporary files, e.g. those created from
Xsomewhere else during a ``make context''.
X.IP (c)
Xscript.out : run a script and trap all the output; the file
X.FL script.out
Xshould contain the concatenation of the script input and the
Xscript output.
XThis file is used by
X.PR ttychk
Xto compute the output tty bandwidth requirements.
X.RE
X.nr II 0
X.LP
XThe program
X.PR makework
Xreads the
X.FL Tmp/workload
Xfile and builds data structures
Xfor each job stream (i.e. each simulated user) describing the home
Xdirectory, command interpreter and its options and standard input and
Xstandard output assignments.
XThereafter
X.PR makework
Xstarts the user program(s) (\c
X.PR /bin/sh
Xabove) and pumps
Xrandom chunks of input to them down pipes
Xso that the aggregate rate across all simulated users does not exceed
X.SV rate
X\(mu
X.SV nusers
Xcharacters per second.
X.LP
XBecause of process creation limits, this test
X\fBmust be run as root\fP.
X.LP
XBecause of open file limits,
X.PR makework
Xwill create \fIclones\fP of itself if
Xthere are too many users for it to simulate alone.
X.LP
XIf the standard input files to the job streams invoke interactive
Xprograms (e.g. \c
X.PR ed ),
Xthen substantial care must be taken that the data
Xpumped down the pipe by
X.PR makework
Xends up at the correct destination.
XThis has been the cause of some catastrophic problems in which only
Xparts of the job streams have been run by
X.PR /bin/sh
Xand the rest has
Xbeen sucked up and thrown away by
X.PR /bin/ed .
X.LP
XTo try and avoid these problems, the program
X.PR keyb
Xhas been
Xcreated to emulate one user typing at a terminal.
X.PR keyb
X(like
X.PR makework )
Xuses the environment variables
X.SV rate
Xand
X.SV tty
X(as set up by
X.PR run )
Xto know how fast to generate output and where the input
Xshould be echoed to.
X.LP
XOnce
X.PR run
Xwork has finished, it is \fBessential\fP
Xthat the following checks be performed.
X.IP (1)
XLook in the file
X.FL Results/log .
XCheck for wild variances in the execution times (a sign that not all job streams
Xare being run to completion), and any obscure error messages that would
Xhave been generated on stderr from
X.PR makework .
XMake sure that the execution times look reasonable.
XOne easy check is that the CPU time for ``n'' users
X\f2must be at least\fP
X\&``n'' times the CPU time for one simulated user, since the CPU times
Xshould be nearly the same for all users in a given run (although
Xthe CPU time per user is expected to rise as the number of concurrent
Xusers increases).
X.IP (2)
XCheck the file
X.FL Results/log.work
Xthat contains echoed comments, status information
Xand shell error output from the simulated user work.
X.nr II 4n
X.LP
XThe lines preceded by a line of the form ``Tmp/userlog.nnn:'' are copies of
Xthe shell error output for simulated user ``nnn''.
XThis should consist of a row of ``# ''s (assuming root's
X.PR /bin/sh
Xprompt is ``# '').
X.LP
XThe lines preceded by a line of the form ``Tmp/masterlog.nnn:'' are
Xthe standard error output from master number ``nnn''.
XMaster 0 is the real master
X.PR makework
Xprocess, the others are clones.
XCheck that there are no messages of the forms,
X.RS
X.nf
X.if t .HS
Xmakework: cannot open %s for std output
Xmakework: chdir to "%s" failed!
Xuser %d job %d pid %d done exit code %d
Xuser %d job %d pid %d done status 0x%x
Xuser %d job %d pid %d done exit code %d status 0x%x
Xclone %d done, pid %d exit code %d
Xclone %d done, pid %d status 0x%x
Xclone %d done, pid %d exit code %d status 0x%x
Xuser %d job %d pid %d killed off
X\&... reason ... pid %d killed off
X.if t .HE
X.fi
X.RE
X\fBAny\fP these messages indicate something has gone terribly wrong.
X.LP
XOn the other hand, messages of the form
X.RS
X.nf
X.if t .HS
Xmaster pid %d
Xclone %d pid %d
Xuser %d job %d pid %d pipe fd %d
Xuser %d job %d pid %d done
Xclone %d done, pid %d
X.if t .HE
X.fi
X.RE
Xare just warm reassurance that everything is going well.
X.nr II 0
X.NH 3.3 Miscellaneous
X.TN x
XLike ``run work'', except the initial filesystem status reporting,
Xtty bandwidth check
Xand clock checks are omitted.
XUseful when using the multi-user test for diagnostic purposes, and the
Xinitial housekeeping is not needed.
X.NH 4 "The Complete Test"
X.LP
XWhen everything is apparently installed and operating correctly,
Xlogin as root, choose another inactive terminal running at 9600 baud
X(/dev/ttyx below) and start the whole charade as follows.
X.SC tty=/dev/ttyx
X.SC "export tty"
X.SC "rm Report/log Report/log.work"
X.SC "./run &"
X.LP
XOn a 4 Mbyte VAX 11/780, simulating 1, 4, 8, 16, 24 and 32
Xusers in the multi-user test, this takes about 5 hours to run!
X.NH 5 "What Does It All Mean?"
X.LP
XFinally one should be in a position to contemplate the summaries in
Xthe
X.FL Results/log
Xfile.
XLook in
X.FL Tools
Xfor the scripts
X.PR mktbl
Xand
X.PR mkcomp
Xto create
X.PR tbl
Xinput directly from the log files
Xfor a single system or to compare two systems.
XThis is most useful in comparison to the same tests run on another
Xsystem, or on another version of the same system.
X.LP
XLots of things can influence the results, and people interpreting
Xthe results should be aware of the following (probably incomplete)
Xlist.
X.IP (1)
XAvailable real memory for the disk block cache and user processes.
X.IP (2)
XThe physical disk hardware; number and type of spindles, controller
Xtype and paths to devices.
X.IP (3)
XThe logical disk arrangement; allocation of critical directories such
Xas
X.PR /tmp ,
X.PR /usr
Xand user filesystem across physical devices, the number
Xand distribution of swap partitions.
X.IP (4)
XStandard of C compiler and optimizer; everything tested is written
Xin C, any improvements here will help everything (even the kernel!).
X.IP (5)
XPhysical block size for swapping and paging; some of the test programs
Xare very small and so may incur large physical i/o costs.
X.IP (6)
XFlavour of UNIX you are using.
X.IP (7)
XThe accuracy of real time measurements and flow control in
X.PR makework .
XCheck the output from
X.PR clock
Xin
X.FL Results/log
Xat the start of the multi-user
Xtest to determine the extent to which a controlling SIGALRM loop
Xmeasures wallclock time -- this can influence elapsed time in the
Xmulti-user test particularly.
X.NH 6 "Caveat Emptor"
X.LP
XThe MUSBUS tests have been widely distributed, and in some cases
Xtheir owners have not treated them kindly.
XThe following list details known pitfalls in running the tests
Xand the subsequent application of the results.
X.IP (1)
XThere are several versions of the test suite, Version 3.3 (and later
Xversions) in particular
Xare very different to earlier versions and results obtained
Xwith different versions of the suite cannot be meaningfully
Xcompared.
XI make no claim for the long-term
Xstability of MUSBUS, and so this evolutionary
Xprocess is likely to continue with future releases of the test suite.
X.IP (2)
XThere is \fBno\fP reason to suspect that the distributed workload
Xfor the multi-user test (i.e. the files
X.FL Tmp/script.?
Xand
X.FL Tmp/workload )
Xare representative of the user work profile at \fByour\fP installation(s).
XBe prepared to alter or rebuild the workload to reflect your
Xexpected system usage.
X.IP (3)
XResults have been known to vary
Xdramatically between releases of the UNIX you
Xare testing.
XThis reflects vendor tuning (sometimes breaking) of the UNIX port
Xand MUSBUS is a useful diagnostic tool in this area, provided the
XMUSBUS version and workload profile remain fixed.
X.IP (4)
XPoints (1) to (3) suggest that uncontrolled and uninformed
Xcomparisons of
XMUSBUS results is dangerous in the extreme.
XThis is the main reason that I have not published the large
Xcollection of results accumulated to date.
X.IP (5)
XRemember that the tests described in Section 3.1 are intended
Xfor \fBdiagnostic\fP use.
XIf you are interested in \fBperformance\fP, you should focus
Xupon the multi-user test described in Section 3.2.
X.IP (6)
XBeware of simulating \fBtoo few\fP users in the multi-user
Xtest.
XUseful information about system throughput and performance
Xunder heavy load conditions can usually be obtained by
Xextrapolation of various measures computed from the
XCPU and elapsed times for the multi-user tests with
Xvarious numbers of users.
XHowever this assumes the machine has been sufficiently loaded to
Xmove out of the \fIlinear\fP part of the performance curves.
XFor very fast machines, this may require emulation of
Xa \fIlarge\fP number of users in the multi-user test.
X.IP (7)
XBeware of simulating \fBtoo many\fP users in the multi-user
Xtest.
XUsing the default value for
X.SV ttys ,
X\fBall\fP simulated
Xtty output is directed to a \fIsingle\fP serial port.
XAs you increase the number of simulated users in the multi-user
Xtest (in response to Point (6) above) the serial port
Xbandwidth may become the limiting resource!
XThis is easy to fix by adding a list of more tty devices to the
Xvalue of
X.SV ttys .
X.IP (8)
XBe warned that the multi-user test has ``broken'' several UNIX
Xports.
XCauses have been identified as implementation (configuration)
Xlimits in the system being tested (e.g. proc slots), real
Xbugs in the port or MUSBUS errors.
XThis list is basically in order of decreasing probability.
X.LP
XCommunication on MUSBUS experiences is welcomed at the
Xelectronic addresses on the first page of this document.
XIf you have found a problem, or can suggest a better testing
Xtechnique please let me know, so that future versions might
Xoffer real (as opposed to cosmetic) enhancements.
End-of-File-Grunt
if test 33719 -ne `cat 'update.033' | wc -c`
then
echo 'shar: transmission error (expected 33719 characters)'
fi
echo 'x - update.034'
if test -f 'update.034'
then
echo 'shar: over-writing existing file update.034'
fi
sed 's/^X//' > update.034 <<'End-of-File-Grunt'
X/McDonell
X0CFred Dagg:g/MUSBUS/s//YABUB/g
X/YABUB
XnnH?The Monash
XWc5wYet Another Boring/Systems
XcwBenchmark1G?^\.NH
Xno.NH 5.99 "Boring Filler"
X.LP
XThis is a significant chunk of new text, added near the endd
Xof the file to accommodate the unlikely simulation of
Xsomeone actually typing this banal monologue and drivel
Xinto afile file, i.e. real text entry (mistakes and all 8^)> ).
XObviously this is a completely bogus hope, since ono-one in their rtightight and sane
Xmind would have initially created this tripe, much less spend valuable
Xtime modifying it.
X.LpP
XOn the other hand, people do use MVS, VMS, MS-DOS and other arcane
Xoperating systems (god knowas why), and indeed if they did not, there
Xwould be nothing for the smart-arse Unix officianodoesadoes (sp?) to poke
Xfun at.
X.LP
Xtoday in Melbourne it is a \n overcast day, slight winds and an expected
Xtop temperature of +17 degrees CElsiuselsius.
XGrunt.?LP
XO.LP
XClearly I am runninf g out of things to say, and I only hope that script
Xwill not have mangled this session to the point where I cannot find the
Xinput text and commands to reconsrttruct a script to give to makework
Xvia a pseudo tty.
XJust imagine the pain that would be required to redo this all using emascs,!/today
X~f\xX
Xo.LP
XIn reality, this is just a test for MUSBUS, to see if it really is as
Xadaptable as I bravely assert.
XIn particular, I am interested in seeing if a vi-based script can
Xbe supported within the basic MUSBUS framework, and if not, how many
Xthings have to be changed.
XTo date, the only problem would appear to be the limitation placed
Xby pseudo ttys, namely
X.NP
XStandard System V implementations do not have pseudo ttys, although
Xa driver has been posted via Usenet.
X.NP
XEach simulated user requires a master/slave pty pair, since multiplexing
Xptys will not work at all!
X.LP
XHaving filled a screen full of garbage, I have just one last thing to say,
X.ce
X.ft B
XGOOD BYE
X.ft P:f temporary
X:w!
XG?wallclock
XnnnGndG?syscall
Xnn:g/script\../p
X
X:q!
End-of-File-Grunt
if test 2022 -ne `cat 'update.034' | wc -c`
then
echo 'shar: transmission error (expected 2022 characters)'
fi
echo 'x - update.035'
if test -f 'update.035'
then
echo 'shar: over-writing existing file update.035'
fi
sed 's/^X//' > update.035 <<'End-of-File-Grunt'
X/quick
Xc2wnot very fast, slightly off-redo.P
XClose behind came a mob of crazed hounds, slobbering after the blood
Xof the brainless hunters who had unwittingly disguised
Xthemselves as foxes ...:g/^\.P/s//.P 1/
X:w temporary
X:q!
End-of-File-Grunt
if test 228 -ne `cat 'update.035' | wc -c`
then
echo 'shar: transmission error (expected 228 characters)'
fi
echo 'x - update.036'
if test -f 'update.036'
then
echo 'shar: over-writing existing file update.036'
fi
sed 's/^X//' > update.036 <<'End-of-File-Grunt'
X.\" This is a small data file for some editing
X.P
XThe cat sat on the mat.
X.P
XThe quick brown fox jumped over the lazy dog.
X.P
XPeter picked a peck of pickled peppers,
Xa peck of pickled peppers were picked by Peter.
End-of-File-Grunt
if test 214 -ne `cat 'update.036' | wc -c`
then
echo 'shar: transmission error (expected 214 characters)'
fi
echo 'x - update.037'
if test -f 'update.037'
then
echo 'shar: over-writing existing file update.037'
fi
sed 's/^X//' > update.037 <<'End-of-File-Grunt'
XText Processing Workload.
End-of-File-Grunt
if test 26 -ne `cat 'update.037' | wc -c`
then
echo 'shar: transmission error (expected 26 characters)'
fi
echo 'x - update.038'
if test -f 'update.038'
then
echo 'shar: over-writing existing file update.038'
fi
sed 's/^X//' > update.038 <<'End-of-File-Grunt'
X#! /bin/sh
X# Use the contents of the file USER to extract the ordinal user number
X# and map this to that last two characters of a pty name.
X# Assumes: can only support 48 users (numbered 0 ... 47) using ptys
X# ttyq0 thru ttyqf, ttyr0 thru ttyrf and ttys0 thru ttysf
Xunum=`cat USER`
Xif test "$unum" -lt 0 -o "$unum" -gt 47
Xthen
X echo "map_pty: number of users \"$unum\" not legal"
X exit 1
Xfi
X
Xawk '
XBEGIN { maj[0]="q"; maj[1]="r"; maj[2]="s"
X hex[0]="a"; hex[1]="b"; hex[2]="c"
X hex[3]="d"; hex[4]="e"; hex[5]="f"
X }
X { printf maj[int($1/16)]
X min=$1%16
X if (min<10) print min
X else print hex[min-10]
X }' USER
X
Xexit 0
End-of-File-Grunt
if test 636 -ne `cat 'update.038' | wc -c`
then
echo 'shar: transmission error (expected 636 characters)'
fi
echo 'x - update.039'
if test -f 'update.039'
then
echo 'shar: over-writing existing file update.039'
fi
sed 's/^X//' > update.039 <<'End-of-File-Grunt'
X#include <stdio.h>
X/*
X * output the tty device name and the matching tty type (from the file ttytype)
X */
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X char *p;
X char *q;
X FILE *f;
X int c;
X int skip = 0;
X char *ttyname();
X char *getenv();
X
X p = ttyname(1); /* stdout, not stdin; unlike tty(1) */
X freopen("term", "w", stdout);
X if (p == (char *)0)
X printf("/dev/unknown ");
X else
X printf("%s ", p);
X
X if (p != (char *)0 && (f = fopen("ttytype", "r")) != NULL) {
X q = p;
X while ((c = getc(f)) != EOF) {
X if (skip) {
X if (c == '\n')
X skip = 0;
X }
X else if (*q++ != c) {
X q = p;
X skip = 1;
X }
X else if (*q == '\0') {
X while ((c = getc(f)) == ' ' || c == '\t')
X ;
X do {
X putchar(c);
X } while ((c = getc(f)) != '\n');
X putchar('\n');
X exit(0);
X }
X }
X }
X
X p = getenv("TERM");
X if (p == (char *)0) {
X putchar('\n');
X exit(1);
X }
X printf("%s\n", p);
X exit(0);
X}
End-of-File-Grunt
if test 965 -ne `cat 'update.039' | wc -c`
then
echo 'shar: transmission error (expected 965 characters)'
fi
echo 'x - update.040'
if test -f 'update.040'
then
echo 'shar: over-writing existing file update.040'
fi
sed 's/^X//' > update.040 <<'End-of-File-Grunt'
XA new text processing workload profile for users that use vi rather
Xthan ed. Requires BSD4.X or similar for pseudo ttys.
X
XTo configure this test properly, check
X(a) ../map_pty does the correct things in mapping an ordinal user number onto
X a valid pty name.
X(b) Edit the file ttytype (``make ttytype'' to create a prototype if it
X doesn't already exist) to include the termcap (terminfo?) names of the
X terminal types attached to the tty devices you are going to use.
X(c) Be aware that each simulated user requires dedicated access to a pty,
X so this will typically limit the maximum number of simulated users.
End-of-File-Grunt
if test 624 -ne `cat 'update.040' | wc -c`
then
echo 'shar: transmission error (expected 624 characters)'
fi
echo 'x - update.041'
if test -f 'update.041'
then
echo 'shar: over-writing existing file update.041'
fi
sed 's/^X//' > update.041 <<'End-of-File-Grunt'
X#! /bin/sh
X# Clean prompt stuff from standard error output in multi-user test.
X# Called from ../cleanup
X# $Header: cleanstderr,v 5.2 87/12/13 07:47:42 kenj Exp $
X
XPS1=`/bin/sh -ic "" 2>&1`
Xsed \
X -e "s/\\${PS1}[0-9][0-9]*$//" \
X -e "s/\\${PS1}//g" \
X -e '/^ *$/d'
End-of-File-Grunt
if test 264 -ne `cat 'update.041' | wc -c`
then
echo 'shar: transmission error (expected 264 characters)'
fi
echo 'x - update.042'
if test -f 'update.042'
then
echo 'shar: over-writing existing file update.042'
fi
sed 's/^X//' > update.042 <<'End-of-File-Grunt'
X%W% /bin/sh -ie
XPATH=XXX:$PATH
Xtermname
XTERM="`cat term | sed 's/.*[ ]//'`"
Xtty=""
Xexport PATH TERM tty
X% Note: used for pseudo ttys, can only support 48 users using ptys
X% ttyq0 thru ttyqf, ttyr0 thru ttyrf and ttys0 thru ttysf
Xptn=`map_pty`
X%% 1 small edit
Xrm -f temporary
Xwait
Xkeyb viscr2.dat >/dev/tty$ptn &
Xvi small.txt </dev/pty$ptn
X%% 2 ls
Xls -l
X%% 3 big edit
Xrm -f temporary
Xwait
Xkeyb viscr1.dat >/dev/tty$ptn &
Xvi big.txt </dev/pty$ptn
X%% 4 spell
Xspell big.txt >/tmp/$$
Xdiff big.spell /tmp/$$
Xrm -f /tmp/$$
X%% 5 nroff
Xnroff big.txt >/tmp/$$
Xrm -f /tmp/$$
X%%
Xrm -f term temporary
End-of-File-Grunt
if test 589 -ne `cat 'update.042' | wc -c`
then
echo 'shar: transmission error (expected 589 characters)'
fi
echo 'x - update.043'
if test -f 'update.043'
then
echo 'shar: over-writing existing file update.043'
fi
sed 's/^X//' > update.043 <<'End-of-File-Grunt'
X# $Header: Makefile,v 5.2 87/12/15 06:39:44 kenj Exp $
XDATA = big.txt viscr2.dat small.txt dummy.c ttytype
XOTHERPROGS = ../keyb ../hanoi ../randmem ../pipe ../syscall ../fstime \
X termname map_pty
X
Xscripts: context script.out
X
Xscript.1: ../mkscript ../mkperm ../fixPATH script.master
X ../mkscript $${nscripts-6} script.master
X ../fixPATH -w
X
Xscript.out: ../mkscript.out script.1 cleanstderr
X ../mkscript.out
X
Xcontext: $(DATA) $(OTHERPROGS) script.master cleanstderr DESCRIPTION README
X
Xmanifest:
X @echo $(DATA)
X
Xclean:
X rm -f *.bad core term temporary USER
X rm -rf .tmp
X
Xpurge: clean
X rm -f $(DATA) termname map_pty script.? script.out
X
Xmodes:
X chmod 555 cleanstderr
X
Xtermname: ../Work_text/termname
X ln ../Work_text/termname
X../Work_text/termname:
X cd ../Work_text ; make termname
X
Xmap_pty: ../Work_text/map_pty
X ln ../Work_text/map_pty
X../Work_text/map_pty:
X cd ../Work_text ; make map_pty
X
Xttytype: ../Work_text/ttytype
X rm -f ttytype
X ln ../Work_text/ttytype .
X../Work_text/ttytype:
X echo "/dev/tty00 vt100" >../Work_text/ttytype
X
Xbig.txt: ../Work_text/big.txt
X rm -f big.txt
X ln ../Work_text/big.txt .
X
Xsmall.txt: ../Work_text/small.txt
X rm -f small.txt
X ln ../Work_text/small.txt .
X
Xviscr2.dat: ../Work_text/viscr2.dat
X rm -f viscr2.dat
X ln ../Work_text/viscr2.dat .
X
Xdummy.c: ../Workload/dummy.c
X rm -f dummy.c
X ln ../Workload/dummy.c .
X
X../keyb:
X cd .. ; make keyb
X
X../hanoi:
X cd .. ; make hanoi
X
X../randmem:
X cd .. ; make randmem
X
X../pipe:
X cd .. ; make pipe
X
X../syscall:
X cd .. ; make syscall
X
X../fstime:
X cd .. ; make fstime
X
X../mkperm:
X cd .. ; make mkperm
X
X.DEFAULT:
X co RCS/$@,v
End-of-File-Grunt
if test 1593 -ne `cat 'update.043' | wc -c`
then
echo 'shar: transmission error (expected 1593 characters)'
fi
echo 'x - update.044'
if test -f 'update.044'
then
echo 'shar: over-writing existing file update.044'
fi
sed 's/^X//' > update.044 <<'End-of-File-Grunt'
X#! /bin/sh
X# Clean prompt stuff from standard error output in multi-user test.
X# Called from ../cleanup
X# $Header: cleanstderr,v 5.2 87/12/13 08:23:05 kenj Exp $
X
XPS1=`/bin/sh -ic "" 2>&1`
Xsed \
X -e "s/\\${PS1}[0-9][0-9\. ]*$//" \
X -e "s/\\${PS1}//g" \
X -e '/^ *$/d'
End-of-File-Grunt
if test 267 -ne `cat 'update.044' | wc -c`
then
echo 'shar: transmission error (expected 267 characters)'
fi
echo 'x - update.045'
if test -f 'update.045'
then
echo 'shar: over-writing existing file update.045'
fi
sed 's/^X//' > update.045 <<'End-of-File-Grunt'
X%W% /bin/sh -ie
XPATH=XXX:$PATH
Xtermname
XTERM="`cat term | sed 's/.*[ ]//'`"
Xtty=""
Xtmp=/tmp/mus$$bus
Xexport PATH TERM tty
X% Note: used for pseudo ttys, can only support 48 users using ptys
X% ttyq0 thru ttyqf, ttyr0 thru ttyrf and ttys0 thru ttysf
Xptn=`map_pty`
X%% Ethernet
Xremote=kermit
Xrm -f $tmp
Xrcp $remote:/etc/termcap $tmp
Xrsh $remote -n rm -f $tmp
Xrcp $tmp $remote:$tmp
Xrsh $remote -n diff /etc/termcap $tmp
Xrsh $remote -n rm -f $tmp
X%% small edit
Xwait
Xkeyb viscr2.dat >/dev/tty$ptn &
Xvi small.txt </dev/pty$ptn
Xrm -f temporary
X%% ls
Xls -l /bin
X%% nroff
Xnroff big.txt >$tmp
X%% hanoi
Xhanoi 22
X%% randmem
Xrandmem -s1024 -n4000000
X%% pipe i/o
Xpipe 10000
X%% syscall
Xsyscall 40000
X%% fstime
Xfstime 1000 /tmp
X%% C compiler
Xcc dummy.c
Xrm a.out
X%%
Xrm -f $tmp term
End-of-File-Grunt
if test 763 -ne `cat 'update.045' | wc -c`
then
echo 'shar: transmission error (expected 763 characters)'
fi
echo 'x - update.046'
if test -f 'update.046'
then
echo 'shar: over-writing existing file update.046'
fi
sed 's/^X//' > update.046 <<'End-of-File-Grunt'
XSystem exerciser -- shake out system faults under simulated load
End-of-File-Grunt
if test 65 -ne `cat 'update.046' | wc -c`
then
echo 'shar: transmission error (expected 65 characters)'
fi
echo 'x - update.047'
if test -f 'update.047'
then
echo 'shar: over-writing existing file update.047'
fi
sed 's/^X//' > update.047 <<'End-of-File-Grunt'
XSystem exerciser workload.
X
XFeel free to modify script.master to add/delete what ever system
Xexerciser test you wish.
X
XNote that the supplied script includes Berkeley Ethernet networking
Xcommands (rsh and rcp) that will certainly *NOT* work on other machines
X(unless you have a host named ``kermit'' on your Internet ...)
End-of-File-Grunt
if test 322 -ne `cat 'update.047' | wc -c`
then
echo 'shar: transmission error (expected 322 characters)'
fi
echo 'x - update.048'
if test -f 'update.048'
then
echo 'shar: over-writing existing file update.048'
fi
sed 's/^X//' > update.048 <<'End-of-File-Grunt'
XXSCRIPTS = Adjust Config mk1 mk2 mkcomp mktbl
XDATAFILES = comptbl.1 comptbl.2 comptbl.3 comptbl.4 comptbl.5 \
X tbl.1 tbl.2 tbl.3 tbl.4 tbl.5
Xcontext: $(DATAFILES) $(XSCRIPTS)
Xmodes: $(XSCRIPTS)
X chmod 555 $(XSCRIPTS)
Xpurge:
Xclean:
X
X.DEFAULT:
X co RCS/$@,v
X
End-of-File-Grunt
if test 257 -ne `cat 'update.048' | wc -c`
then
echo 'shar: transmission error (expected 257 characters)'
fi