UNIXPC Disk Exerciser Benchmarker for WD2010 steprate 14 testing.
Lenny Tropiano
lenny at icus.islp.ny.us
Mon Aug 28 12:58:03 AEST 1989
Since a got more than 5 requests for this, I decided to clean up my
first hack, make it a little more useful, and post it to the net. Basically
here's a disk exerciser that will show you if the WD2010 and the step-rate
change to 14 in the iv-description for the VHB of the disk makes any
difference. I noticed that the best performance results occured on
the long and converging seek tests. Random and sequential seeking
seemed to remain constant... So basically the longer the seek the
better the performance achieved. So far it doesn't seem to be
hindering the performance! I noticed that John Milton posted the
WD1010 steprate table, and Peter Fales followed up with the corrections
for 14 and 15 for the WD2010 (Thanks). Saved me from digging up my
WD2010 spec sheets ...
Enclosed is the program, a quicky manual page, a testit shell script,
and my test data on my 40MB UNIX pc. I still haven't had the chance
to put the WD2010 in icus (my two drive 134MB total machine ...) But
I assume the results should be better for a 67MB drive because the
seeking will be further.
--- cut here --- --- cut here --- --- cut here --- --- cut here ---
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of shell archive."
# Contents: README Makefile exercise.1 exercise.c testit data
# data/long_rand0 data/long_rand14 data/seq_conv0 data/seq_conv14
# Wrapped by lenny at icus on Sun Aug 27 22:50:19 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f README -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"README\"
else
echo shar: Extracting \"README\" \(841 characters\)
sed "s/^X//" >README <<'END_OF_README'
XSince I got about 10 requests for this ... I cleaned it up, and am posting
Xit. I'd like to hear the results out in the field with different UNIX PC's
Xand their values. Send me some output files and I'll summarize. Please
Xmake sure you include the disk type, manufacturer, seek time, etc...
X
XThe best way to update the VHB is to:
X
X# iv -dv /dev/rfp000 > HD.desc (or /dev/rfp010)
X# vi HD.desc
X
XChange step-rate to 14 (or 0).
X
X# iv -uv /dev/rfp000 HD.desc
X
XDevice type: HD Name: WINCHE
XCylinders: 1024 Heads: 5 Sectors: 17
X
X* Phase 1 - Initializing Internal VHB
X* Phase 2 - Writing out new VHB
X* Phase 3 - Writing out new BBT
X* Phase 4 - Allocating download areas.
X Writing out new loader.
X 3 partitions, 23 blocks for loader, Bad Block Table Allocated
X
X[ make sure you run a reboot before running the exercise benchmark ]
X
END_OF_README
if test 841 -ne `wc -c <README`; then
echo shar: \"README\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"Makefile\"
else
echo shar: Extracting \"Makefile\" \(609 characters\)
sed "s/^X//" >Makefile <<'END_OF_Makefile'
X#
X# Makefile to compile exercise.c (Disk Exerciser)
X# By Lenny Tropiano
X# (c)1989 ICUS Software Systems UUCP: ...icus!lenny -or- lenny at icus.islp.ny.us
X#
XCFLAGS=-v -O
XLDFLAGS=-s
XLIBS=/lib/crt0s.o /lib/shlib.ifile
XMAN=/usr/man/man1
XBIN=/usr/lbin
X#
Xexercise: exercise.o
X @echo "Loading ..."
X $(LD) $(LDFLAGS) -o exercise exercise.o $(LIBS)
X#
Xinstall: exercise
X cp exercise.1 $(MAN)/
X chown bin $(MAN)/exercise.1
X chgrp bin $(MAN)/exercise.1
X chmod 644 $(MAN)/exercise.1
X cp exercise $(BIN)/
X chown root $(BIN)/exercise
X chgrp sys $(BIN)/exercise
X chmod 700 $(BIN)/exercise
X#
Xclean:
X rm -f exercise *.o core
END_OF_Makefile
if test 609 -ne `wc -c <Makefile`; then
echo shar: \"Makefile\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f exercise.1 -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"exercise.1\"
else
echo shar: Extracting \"exercise.1\" \(2562 characters\)
sed "s/^X//" >exercise.1 <<'END_OF_exercise.1'
X.TH EXERCISE 1L LOCAL
X.SH NAME
Xexercise \- UNIX PC Disk Exerciser
X.SH SYNOPSIS
X.B exercise
X[-lcsrV] [-i iter] [-n step] [-o outfile] device [device ..]
X.SH DESCRIPTION
X.B exercise
Xwill test the UNIX PC's disks to see if some theories about switching
Xthe WD1010 with the pin-compatible WD2010, and updating the VHB to change
Xthe step-rate to 14, from it's previous value of 0. This program can
Xbe used as a benchmark for a before and after view of the performance of the
Xdisk. It will perform several different tests and save the output in a file.
X(Defaults to disk.out).
X
X.RE
X
X.SH OPTIONS
XExercise can be run with the following options.
X
X.TP
X-l
XThis option will perform long seeks on the hard disk, the disk will seek
Xfrom the 0th position to the last possible position on the hard disk.
X.TP
X-c
XThis will perform converging seeks. Starting at 0th and the last position
Xon the hard disk, the 0th position will be increased by steptrk (see -n
Xoption) and the last position will be decreased by steptrk until one
Xsurpasses the other.
X.TP
X-s
XThis will perform sequential seeks, stepping each time by steptrk.
X.TP
X-r
XThis will perform random seeking, starting at 0th position each time
Xgoing to a random cylinder and head.
X.TP
X-V
XVerbosity flag, when turned on each iteration and it's time is written
Xto the output file.
X.TP
X-i iter
XSet the number of iterations to a different value. (Default = 100)
X.TP
X-n steptrk
XSet the number of tracks to step at each time. (Default = 10)
X.TP
X-o outfile
XSet the name of the output file for reporting information. (Default = disk.out)
X.SH EXAMPLES
X.B
XHere are some examples for using exercise.
X.nf
X
Xexercise -l /dev/rfp000
X # Perform 100 long seeks, and show average
X
Xexercise -lV /dev/rfp000
X # Perform 100 long seeks, and show all iterations
X and the average
X
Xexercise -sV -n 20 -i 5 /dev/rfp000
X # Perform 5 sequential seeks for the entire
X disk, stepping each time by 20 tracks, show
X each iterations and the average
X
Xexercise -crV -n 25 -i 10 -o OUTFILE /dev/rfp000 /dev/rfp010
X # Perform 10 converging seeks for the entire
X two disks, stepping each time by 25 tracks,
X as well as, 10 random seeks, placing the
X output in OUTFILE. Show each iterations
X and the average.
X.fi
X
X.RE
X.SH FILES
X.nf
X/dev/rfp000 Slice 0 of the raw hard disk 1
X/dev/rfp010 Slice 0 of the raw hard disk 2
X/dev/rfp020 Slice 0 of the raw floppy
Xdisk.out Default name for the output file
X.fi
X.SH SEE ALSO
Xlseek(2), read(2), iv(1M)
X.SH AUTHOR
X.RS
X.PP
XLenny Tropiano (lenny at icus.islp.ny.us)
X.RE
END_OF_exercise.1
if test 2562 -ne `wc -c <exercise.1`; then
echo shar: \"exercise.1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f exercise.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"exercise.c\"
else
echo shar: Extracting \"exercise.c\" \(10191 characters\)
sed "s/^X//" >exercise.c <<'END_OF_exercise.c'
X/************************************************************************\
X** **
X** Program name: exercise.c (Exercise the disk with various test) **
X** Programmer: Lenny Tropiano **
X** E-Mail address: ...!icus!lenny -or- lenny at icus.islp.ny.us **
X** Organization: ICUS Software Systems (c)1989 **
X** Date: August 25, 1989 **
X** **
X**************************************************************************
X** **
X** Program use: This program is used as a crude benchmark to test some **
X** theories to see if the WD2010 and setting the step- **
X** rate to 14 as a disk seek improvement. **
X** **
X** Since this started as a quick hack, I cleaned it up **
X** a bit and then added a few options ... Excuse the **
X** crudeness in spots ... **
X** **
X** Disclaimer: Mileage will vary from disk to disk, this program just **
X** gives a relative approximation to how the disk is **
X** seeking. The time values are in 1/60ths of a second **
X** the value that times(2) system call returns. When **
X** testing your disk, as long as the time units remain **
X** constant, you should be able to tell if the the step- **
X** rates improved. **
X** **
X**************************************************************************
X** Permission is granted to distribute this program by any means as **
X** long as credit is given for my work. I would also like to see **
X** any modifications or enhancements to this program. **
X\************************************************************************/
X
X#include <stdio.h>
X#include <fcntl.h>
X#include <sys/types.h>
X#include <sys/gdioctl.h>
X#include <sys/times.h>
X
X#define DBUFSIZE 512
X
Xchar *progname, /* the name of this program */
X *ofile; /* output report file name */
XFILE *outfp; /* file pointer to output file */
Xint diskfd; /* file descriptor for disk */
Xchar dskbuf[DBUFSIZE], /* a buffer to read into */
X device[12]; /* device name /dev/rfp0n0 */
Xstruct gdctl gdc; /* gdisk control structure */
Xstruct tms timebuf; /* for system call times(2) */
Xint iter; /* maximum iterations */
Xint steptrk; /* step n tracks at a time */
Xint verbose; /* verbosity flag */
Xlong dskmaxseek; /* maximum seek point on disk */
Xushort dskmaxcyl; /* maximum cylinder point */
Xushort dskmaxhd; /* maximum head point */
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X int c;
X extern int optind; /* for use with getopt(3C) */
X extern char *optarg;
X int longseek,
X convgseek,
X seqseek,
X randseek,
X errflg;
X
X progname = argv[0];
X
X longseek = convgseek = seqseek = randseek = errflg = 0;
X iter = 100;
X steptrk = 10;
X ofile = "disk.out"; /* default setting for output file */
X
X while ((c = getopt(argc, argv, "lcsrV?o:i:n:")) != EOF)
X switch (c) {
X case 'l':
X longseek = 1;
X break;
X case 'c':
X convgseek = 1;
X break;
X case 's':
X seqseek = 1;
X break;
X case 'r':
X randseek = 1;
X break;
X case 'V':
X verbose = 1;
X break;
X case 'o':
X ofile = optarg;
X break;
X case 'i':
X iter = atoi(optarg);
X break;
X case 'n':
X steptrk = atoi(optarg);
X break;
X case '?':
X errflg = 1;
X break;
X }
X
X if (errflg || (!longseek && !convgseek && !seqseek && !randseek) ||
X optind == argc) {
X printf("usage: %s [-lcsrV] [-i iter] [-n step] [-o outfile] device [device ..]\n", progname);
X exit(1);
X }
X
X if ((outfp = fopen(ofile,"w")) == NULL) {
X fprintf(stderr,"Cannot open output report file <%s> for write.\n",
X ofile);
X perror(progname);
X exit(1);
X }
X
X while (optind != argc) {
X
X strncpy(device, argv[optind], 11);
X
X if ((strcmp(device,"/dev/rfp000") != 0) &&
X (strcmp(device,"/dev/rfp010") != 0) &&
X (strcmp(device,"/dev/rfp020") != 0)) {
X fprintf(stderr,"%s: Specify slice 0 of the raw disk.\n",
X device);
X exit(1);
X }
X
X if ((diskfd = open(device, O_RDONLY)) < 0) {
X fprintf(stderr,"Cannot open device <%s> for read.\n",
X device);
X perror(progname);
X exit(1);
X }
X
X if (ioctl(diskfd, GDGETA, &gdc) < 0) {
X fprintf(stderr,"Cannot read VHB to get gdctl structure.\n");
X perror(progname);
X exit(1);
X }
X
X
X fprintf(outfp,"\nUNIXPC Disk Exerciser for device: %s\n\n",
X device);
X
X fprintf(outfp,
X "Disk name: %-6.6s Cylinders: %4d Heads: %2d\n",
X gdc.params.name, gdc.params.cyls, gdc.params.heads);
X fprintf(outfp,"Step rate: %2d\n\n", gdc.params.step);
X
X dskmaxcyl = gdc.params.cyls;
X dskmaxhd = gdc.params.heads;
X
X /* logical 1024 byte blocks */
X dskmaxseek = (long)(((((gdc.params.psectrk & ~0x01) *
X gdc.params.sectorsz) / 1024) *
X dskmaxhd * dskmaxcyl) * 1024) - DBUFSIZE;
X
X fprintf(outfp, "Max Seek Distance = %d\n", dskmaxseek);
X
X if (longseek)
X Long_Seeks();
X
X if (convgseek)
X Converging_Seeks();
X
X if (seqseek)
X Sequential_Seeks();
X
X if (randseek)
X Random_Seeks();
X
X optind++;
X }
X fclose(outfp);
X close(diskfd);
X exit(0);
X}
X
XLong_Seeks()
X{
X int i, bytes, tavg;
X long tbefore, tafter;
X
X fprintf(outfp,"** Long Seeks ... \n");
X
X tavg = 0;
X for (i=0;i<iter;i++) {
X tbefore = times(&timebuf);
X if (lseek(diskfd, 0L, 0) < 0) {
X fprintf(outfp, "seek to pos 0 failed, iter=%d\n", i);
X exit(1);
X }
X if ((bytes = read(diskfd, dskbuf, DBUFSIZE)) != DBUFSIZE) {
X fprintf(outfp, "read buffer @%d failed, bytes=%d, iter=%d\n", 0, bytes, i);
X if (bytes < 0)
X perror("read");
X exit(1);
X }
X if (lseek(diskfd, (long)dskmaxseek, 0) < 0) {
X fprintf(outfp, "seek to pos %d failed, iter=%d\n",
X dskmaxseek, i);
X exit(1);
X }
X if ((bytes = read(diskfd, dskbuf, DBUFSIZE)) != DBUFSIZE) {
X fprintf(outfp, "read buffer @%d failed, bytes=%d, iter=%d\n", dskmaxseek, bytes, i);
X if (bytes < 0)
X perror("read");
X exit(1);
X }
X tafter = times(&timebuf);
X
X if (verbose)
X fprintf(outfp, "iter[%d]: %d\n", i, tafter-tbefore);
X
X tavg += (tafter - tbefore);
X }
X fprintf(outfp,"\nAverage seek time: %d\n\n", tavg / iter);
X}
X
XConverging_Seeks()
X{
X int i, bytes, tavg;
X long tbefore, tafter;
X long left, right;
X
X fprintf(outfp,"** Converging Seeks ... \n");
X
X tavg = 0;
X
X
X for (i=0;i<iter;i++) {
X left = 0; /* left seek ---> | <---- right seek */
X right = dskmaxseek;
X tbefore = times(&timebuf);
X while (left < right) {
X if (lseek(diskfd, left, 0) < 0) {
X fprintf(outfp, "seek to pos %d failed, iter=%d\n",
X left, i);
X exit(1);
X }
X if ((bytes = read(diskfd, dskbuf, DBUFSIZE)) != DBUFSIZE) {
X fprintf(outfp, "read buffer @%d failed, bytes=%d, iter=%d\n", left, bytes, i);
X if (bytes < 0)
X perror("read");
X exit(1);
X }
X if (lseek(diskfd, right, 0) < 0) {
X fprintf(outfp, "seek to pos %d failed, iter=%d\n",
X right, i);
X exit(1);
X }
X if ((bytes = read(diskfd, dskbuf, DBUFSIZE)) != DBUFSIZE) {
X fprintf(outfp, "read buffer @%d failed, bytes=%d, iter=%d\n", right, bytes, i);
X if (bytes < 0)
X perror("read");
X exit(1);
X }
X
X /* move 10 tracks at a time left and right */
X left += (gdc.params.sectorsz * gdc.params.psectrk) * steptrk;
X right -= (gdc.params.sectorsz * gdc.params.psectrk) * steptrk;
X
X }
X tafter = times(&timebuf);
X if (verbose)
X fprintf(outfp, "iter[%d]: %d\n", i, tafter-tbefore);
X
X tavg += (tafter - tbefore);
X }
X fprintf(outfp,"\nAverage seek time: %d\n\n", tavg / iter);
X}
X
XSequential_Seeks()
X{
X int i, bytes, tavg;
X long tbefore, tafter, curpos;
X
X fprintf(outfp,"** Sequential Seeks ... \n");
X
X tavg = 0;
X for (i=0;i<iter;i++) {
X curpos = 0;
X tbefore = times(&timebuf);
X do {
X if (lseek(diskfd, curpos, 0) < 0) {
X fprintf(outfp, "seek to pos 0 failed, iter=%d\n", i);
X exit(1);
X }
X if ((bytes = read(diskfd, dskbuf, DBUFSIZE)) != DBUFSIZE) {
X fprintf(outfp, "read buffer @%d failed, bytes=%d, iter=%d\n", 0, bytes, i);
X if (bytes < 0)
X perror("read");
X exit(1);
X }
X curpos += (gdc.params.sectorsz * gdc.params.psectrk) *
X steptrk;
X } while (curpos < dskmaxseek);
X tafter = times(&timebuf);
X
X if (verbose)
X fprintf(outfp, "iter[%d]: %d\n", i, tafter-tbefore);
X
X tavg += (tafter - tbefore);
X }
X fprintf(outfp,"\nAverage seek time: %d\n\n", tavg / iter);
X}
X
XRandom_Seeks()
X{
X int i, bytes, tavg;
X long tbefore, tafter, seekloc, randcyl, randhead;
X
X fprintf(outfp,"** Random Seeks ... \n");
X
X tavg = 0;
X srand(getpid()); /* set the seed */
X
X for (i=0;i<iter;i++) {
X tbefore = times(&timebuf);
X if (lseek(diskfd, 0L, 0) < 0) {
X fprintf(outfp, "seek to pos 0 failed, iter=%d\n", i);
X exit(1);
X }
X if ((bytes = read(diskfd, dskbuf, DBUFSIZE)) != DBUFSIZE) {
X fprintf(outfp, "read buffer @%d failed, bytes=%d, iter=%d\n", 0, bytes, i);
X if (bytes < 0)
X perror("read");
X exit(1);
X }
X randcyl = (rand() % dskmaxcyl) + 1;
X randhead = (rand() % dskmaxhd) + 1;
X
X seekloc = (long)(((((gdc.params.psectrk & ~0x01) *
X gdc.params.sectorsz) / 1024) *
X randhead * randcyl) * 1024) - DBUFSIZE;
X
X
X if (lseek(diskfd, (long)seekloc, 0) < 0) {
X fprintf(outfp, "seek to pos %d failed, iter=%d\n",
X seekloc, i);
X exit(1);
X }
X if ((bytes = read(diskfd, dskbuf, DBUFSIZE)) != DBUFSIZE) {
X fprintf(outfp, "read buffer @%d failed, bytes=%d, iter=%d\n", dskmaxseek, bytes, i);
X if (bytes < 0)
X perror("read");
X exit(1);
X }
X tafter = times(&timebuf);
X
X if (verbose)
X fprintf(outfp, "iter[%d]: %d (Cyl=%d, Head=%d)\n",
X i, tafter-tbefore, randcyl, randhead);
X
X tavg += (tafter - tbefore);
X }
X fprintf(outfp,"\nAverage seek time: %d\n\n", tavg / iter);
X}
X
END_OF_exercise.c
if test 10191 -ne `wc -c <exercise.c`; then
echo shar: \"exercise.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f testit -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"testit\"
else
echo shar: Extracting \"testit\" \(645 characters\)
sed "s/^X//" >testit <<'END_OF_testit'
X# Simple script to test the disk's performance based on the exercise
X# program.
X#
X# By Lenny Tropiano ICUS Software Systems (c) 1989
X#
XSTEP=`iv -dv /dev/rfp000 | grep steprate | sed 's/steprate.//gp'`
Xecho "Step rate = ${STEP}"
X#
X# Let it take all the CPU ... (therefore the great nice value!)
X# WARNING: Make sure no one else is running on your machine ... Or run
X# this from the Floppy UNIX
X#
Xecho "Running Long & Random Seek Disk test ..."
Xnice --39 exercise -lrV -i 50 -o long_rand${STEP} /dev/rfp000
Xecho "Running Sequential & Converging Seek Disk test ..."
Xnice --39 exercise -scV -i 5 -n 20 -o seq_conv${STEP} /dev/rfp000
END_OF_testit
if test 645 -ne `wc -c <testit`; then
echo shar: \"testit\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test ! -d data ; then
echo shar: Creating directory \"data\"
mkdir data
fi
if test -f data/long_rand0 -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"data/long_rand0\"
else
echo shar: Extracting \"data/long_rand0\" \(2350 characters\)
sed "s/^X//" >data/long_rand0 <<'END_OF_data/long_rand0'
X
XUNIXPC Disk Exerciser for device: /dev/rfp000
X
XDisk name: ms6053 Cylinders: 1024 Heads: 5
XStep rate: 0
X
XMax Seek Distance = 41942528
X** Long Seeks ...
Xiter[0]: 10
Xiter[1]: 12
Xiter[2]: 12
Xiter[3]: 12
Xiter[4]: 12
Xiter[5]: 12
Xiter[6]: 12
Xiter[7]: 12
Xiter[8]: 12
Xiter[9]: 12
Xiter[10]: 12
Xiter[11]: 12
Xiter[12]: 12
Xiter[13]: 12
Xiter[14]: 12
Xiter[15]: 12
Xiter[16]: 12
Xiter[17]: 12
Xiter[18]: 12
Xiter[19]: 12
Xiter[20]: 12
Xiter[21]: 12
Xiter[22]: 12
Xiter[23]: 12
Xiter[24]: 12
Xiter[25]: 12
Xiter[26]: 12
Xiter[27]: 12
Xiter[28]: 12
Xiter[29]: 12
Xiter[30]: 12
Xiter[31]: 12
Xiter[32]: 12
Xiter[33]: 12
Xiter[34]: 12
Xiter[35]: 12
Xiter[36]: 12
Xiter[37]: 12
Xiter[38]: 12
Xiter[39]: 12
Xiter[40]: 12
Xiter[41]: 12
Xiter[42]: 12
Xiter[43]: 12
Xiter[44]: 12
Xiter[45]: 12
Xiter[46]: 12
Xiter[47]: 12
Xiter[48]: 12
Xiter[49]: 12
X
XAverage seek time: 11
X
X** Random Seeks ...
Xiter[0]: 9 (Cyl=613, Head=2)
Xiter[1]: 6 (Cyl=448, Head=3)
Xiter[2]: 6 (Cyl=379, Head=3)
Xiter[3]: 5 (Cyl=461, Head=1)
Xiter[4]: 4 (Cyl=342, Head=1)
Xiter[5]: 7 (Cyl=845, Head=4)
Xiter[6]: 7 (Cyl=483, Head=1)
Xiter[7]: 5 (Cyl=915, Head=2)
Xiter[8]: 5 (Cyl=207, Head=3)
Xiter[9]: 4 (Cyl=81, Head=5)
Xiter[10]: 6 (Cyl=758, Head=4)
Xiter[11]: 6 (Cyl=233, Head=2)
Xiter[12]: 4 (Cyl=144, Head=5)
Xiter[13]: 4 (Cyl=116, Head=4)
Xiter[14]: 3 (Cyl=26, Head=1)
Xiter[15]: 3 (Cyl=142, Head=1)
Xiter[16]: 3 (Cyl=6, Head=4)
Xiter[17]: 3 (Cyl=232, Head=1)
Xiter[18]: 5 (Cyl=802, Head=2)
Xiter[19]: 8 (Cyl=907, Head=5)
Xiter[20]: 8 (Cyl=968, Head=2)
Xiter[21]: 6 (Cyl=493, Head=3)
Xiter[22]: 5 (Cyl=459, Head=1)
Xiter[23]: 7 (Cyl=693, Head=5)
Xiter[24]: 7 (Cyl=796, Head=1)
Xiter[25]: 4 (Cyl=78, Head=3)
Xiter[26]: 7 (Cyl=832, Head=5)
Xiter[27]: 7 (Cyl=45, Head=5)
Xiter[28]: 4 (Cyl=370, Head=1)
Xiter[29]: 6 (Cyl=739, Head=3)
Xiter[30]: 7 (Cyl=407, Head=4)
Xiter[31]: 5 (Cyl=226, Head=1)
Xiter[32]: 6 (Cyl=998, Head=3)
Xiter[33]: 5 (Cyl=15, Head=2)
Xiter[34]: 6 (Cyl=852, Head=4)
Xiter[35]: 8 (Cyl=523, Head=3)
Xiter[36]: 5 (Cyl=704, Head=1)
Xiter[37]: 7 (Cyl=833, Head=5)
Xiter[38]: 8 (Cyl=227, Head=4)
Xiter[39]: 6 (Cyl=687, Head=2)
Xiter[40]: 5 (Cyl=757, Head=1)
Xiter[41]: 7 (Cyl=629, Head=4)
Xiter[42]: 6 (Cyl=544, Head=1)
Xiter[43]: 5 (Cyl=288, Head=4)
Xiter[44]: 8 (Cyl=934, Head=4)
Xiter[45]: 9 (Cyl=947, Head=3)
Xiter[46]: 8 (Cyl=977, Head=3)
Xiter[47]: 6 (Cyl=121, Head=2)
Xiter[48]: 5 (Cyl=926, Head=2)
Xiter[49]: 6 (Cyl=653, Head=3)
X
XAverage seek time: 5
X
END_OF_data/long_rand0
if test 2350 -ne `wc -c <data/long_rand0`; then
echo shar: \"data/long_rand0\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f data/long_rand14 -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"data/long_rand14\"
else
echo shar: Extracting \"data/long_rand14\" \(2313 characters\)
sed "s/^X//" >data/long_rand14 <<'END_OF_data/long_rand14'
X
XUNIXPC Disk Exerciser for device: /dev/rfp000
X
XDisk name: ms6053 Cylinders: 1024 Heads: 5
XStep rate: 14
X
XMax Seek Distance = 41942528
X** Long Seeks ...
Xiter[0]: 7
Xiter[1]: 9
Xiter[2]: 9
Xiter[3]: 9
Xiter[4]: 9
Xiter[5]: 10
Xiter[6]: 9
Xiter[7]: 9
Xiter[8]: 9
Xiter[9]: 10
Xiter[10]: 10
Xiter[11]: 9
Xiter[12]: 10
Xiter[13]: 9
Xiter[14]: 9
Xiter[15]: 10
Xiter[16]: 9
Xiter[17]: 9
Xiter[18]: 9
Xiter[19]: 10
Xiter[20]: 9
Xiter[21]: 9
Xiter[22]: 10
Xiter[23]: 9
Xiter[24]: 10
Xiter[25]: 10
Xiter[26]: 10
Xiter[27]: 10
Xiter[28]: 10
Xiter[29]: 9
Xiter[30]: 9
Xiter[31]: 9
Xiter[32]: 9
Xiter[33]: 9
Xiter[34]: 9
Xiter[35]: 9
Xiter[36]: 9
Xiter[37]: 9
Xiter[38]: 10
Xiter[39]: 9
Xiter[40]: 10
Xiter[41]: 10
Xiter[42]: 9
Xiter[43]: 9
Xiter[44]: 9
Xiter[45]: 9
Xiter[46]: 9
Xiter[47]: 9
Xiter[48]: 9
Xiter[49]: 9
X
XAverage seek time: 9
X
X** Random Seeks ...
Xiter[0]: 7 (Cyl=94, Head=4)
Xiter[1]: 4 (Cyl=267, Head=1)
Xiter[2]: 6 (Cyl=993, Head=4)
Xiter[3]: 6 (Cyl=631, Head=1)
Xiter[4]: 4 (Cyl=891, Head=1)
Xiter[5]: 4 (Cyl=717, Head=1)
Xiter[6]: 3 (Cyl=7, Head=3)
Xiter[7]: 3 (Cyl=55, Head=3)
Xiter[8]: 4 (Cyl=564, Head=1)
Xiter[9]: 5 (Cyl=468, Head=5)
Xiter[10]: 5 (Cyl=240, Head=1)
Xiter[11]: 4 (Cyl=507, Head=1)
Xiter[12]: 6 (Cyl=658, Head=5)
Xiter[13]: 7 (Cyl=335, Head=5)
Xiter[14]: 5 (Cyl=202, Head=1)
Xiter[15]: 4 (Cyl=647, Head=1)
Xiter[16]: 5 (Cyl=841, Head=2)
Xiter[17]: 6 (Cyl=762, Head=3)
Xiter[18]: 6 (Cyl=303, Head=4)
Xiter[19]: 8 (Cyl=1005, Head=5)
Xiter[20]: 8 (Cyl=312, Head=4)
Xiter[21]: 5 (Cyl=157, Head=3)
Xiter[22]: 4 (Cyl=166, Head=3)
Xiter[23]: 5 (Cyl=267, Head=5)
Xiter[24]: 5 (Cyl=238, Head=1)
Xiter[25]: 5 (Cyl=394, Head=4)
Xiter[26]: 5 (Cyl=34, Head=4)
Xiter[27]: 5 (Cyl=777, Head=3)
Xiter[28]: 5 (Cyl=33, Head=4)
Xiter[29]: 4 (Cyl=32, Head=2)
Xiter[30]: 3 (Cyl=128, Head=5)
Xiter[31]: 5 (Cyl=733, Head=2)
Xiter[32]: 7 (Cyl=823, Head=4)
Xiter[33]: 7 (Cyl=845, Head=3)
Xiter[34]: 4 (Cyl=12, Head=4)
Xiter[35]: 5 (Cyl=713, Head=4)
Xiter[36]: 5 (Cyl=703, Head=1)
Xiter[37]: 3 (Cyl=6, Head=4)
Xiter[38]: 4 (Cyl=1018, Head=1)
Xiter[39]: 7 (Cyl=986, Head=3)
Xiter[40]: 7 (Cyl=247, Head=4)
Xiter[41]: 5 (Cyl=719, Head=3)
Xiter[42]: 6 (Cyl=495, Head=5)
Xiter[43]: 6 (Cyl=873, Head=3)
Xiter[44]: 6 (Cyl=838, Head=3)
Xiter[45]: 6 (Cyl=311, Head=5)
Xiter[46]: 6 (Cyl=376, Head=3)
Xiter[47]: 5 (Cyl=156, Head=1)
Xiter[48]: 5 (Cyl=961, Head=3)
Xiter[49]: 7 (Cyl=858, Head=4)
X
XAverage seek time: 5
X
END_OF_data/long_rand14
if test 2313 -ne `wc -c <data/long_rand14`; then
echo shar: \"data/long_rand14\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f data/seq_conv0 -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"data/seq_conv0\"
else
echo shar: Extracting \"data/seq_conv0\" \(370 characters\)
sed "s/^X//" >data/seq_conv0 <<'END_OF_data/seq_conv0'
X
XUNIXPC Disk Exerciser for device: /dev/rfp000
X
XDisk name: ms6053 Cylinders: 1024 Heads: 5
XStep rate: 0
X
XMax Seek Distance = 41942528
X** Converging Seeks ...
Xiter[0]: 908
Xiter[1]: 921
Xiter[2]: 909
Xiter[3]: 907
Xiter[4]: 908
X
XAverage seek time: 910
X
X** Sequential Seeks ...
Xiter[0]: 304
Xiter[1]: 306
Xiter[2]: 314
Xiter[3]: 306
Xiter[4]: 306
X
XAverage seek time: 307
X
END_OF_data/seq_conv0
if test 370 -ne `wc -c <data/seq_conv0`; then
echo shar: \"data/seq_conv0\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f data/seq_conv14 -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"data/seq_conv14\"
else
echo shar: Extracting \"data/seq_conv14\" \(370 characters\)
sed "s/^X//" >data/seq_conv14 <<'END_OF_data/seq_conv14'
X
XUNIXPC Disk Exerciser for device: /dev/rfp000
X
XDisk name: ms6053 Cylinders: 1024 Heads: 5
XStep rate: 14
X
XMax Seek Distance = 41942528
X** Converging Seeks ...
Xiter[0]: 764
Xiter[1]: 757
Xiter[2]: 761
Xiter[3]: 767
Xiter[4]: 770
X
XAverage seek time: 763
X
X** Sequential Seeks ...
Xiter[0]: 303
Xiter[1]: 305
Xiter[2]: 305
Xiter[3]: 305
Xiter[4]: 305
X
XAverage seek time: 304
X
END_OF_data/seq_conv14
if test 370 -ne `wc -c <data/seq_conv14`; then
echo shar: \"data/seq_conv14\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of shell archive.
exit 0
--
Lenny Tropiano ICUS Software Systems [w] +1 (516) 589-7930
lenny at icus.islp.ny.us Telex; 154232428 ICUS [h] +1 (516) 968-8576
{ames,pacbell,decuac,hombre,talcott,sbcs}!icus!lenny attmail!icus!lenny
ICUS Software Systems -- PO Box 1; Islip Terrace, NY 11752
More information about the Unix-pc.sources
mailing list