disk.modspec

目前最精确的磁盘模拟器的第3版

INIT result->readaheadifidle = i;

This specifies whether or not prefetching should be initiated by the
disk when a read request is completely satisfied by cached data
(i.e.,~a ``full read hit'').


PARAM Read any free blocks		I	1 
TEST RANGE(i,0,1)
INIT result->readanyfreeblocks = i;

This specifies whether or not disk sectors logically prior to the
requested sectors should be read into the cache if they pass under the
read/write head prior to reaching the requested data (e.g.,~during
rotational latency).


PARAM Fast write level			I	1 
TEST RANGE(i,0,2) 
INIT result->fastwrites = i;

This specifies the type of write-back caching implemented.  

0~indicates that write-back caching is disabled (i.e.,~all dirty data
must be written to the disk media prior to sending a completion
message).

1~indicates that write-back caching is enabled for contiguous
sequential write request streams.  That is, as long as each request
arriving at the disk is a write request that ``appends'' to the
current segment of dirty data, a completion message will be returned
for each new request as soon as all of its data have been transferred
over the bus to the disk buffer/cache.

2~indicates that write-back caching is enabled for contiguous
sequential write request streams even if they are intermixed with read
or non-appending write requests, although before any such request is
serviced by the disk, all of the dirty write data must be flushed to
the media.  A scheduling algorithm that gives precedence to sequential
writes would maximize the effectiveness of this option.


PARAM Combine seq writes		I	1 
TEST RANGE(i,0,1)
INIT result->writecomb = i;

This specifies whether or not sequential data from separate write requests
can share a common cache segment.  If true~(1), data are typically
appended at the end of a previous request's dirty data.  However, if
all of the data in a cache segment are dirty, and no mechanical
activity has begun on behalf of the request(s) using that segment,
``prepending'' of additional dirty data are allowed provided that the
resulting cache segment contains a single contiguous set of dirty
sectors.


PARAM Stop prefetch in sector		I	1 
TEST RANGE(i,0,1)
INIT result->stopinsector = i;

This specifies whether or not a prefetch may be aborted in the ``middle''
of reading a sector off the media.  If false~(0), prefetch activity is
only aborted at sector boundaries.


PARAM Disconnect write if seek		I	1 
TEST RANGE(i,0,1) 
INIT result->disconnectinseek = i;

This specifies whether or not the disk should disconnect from the bus if
the actuator is still in motion (seeking) when the last of a write
request's data has been transferred to the disk buffer/cache.

PARAM Write hit stop prefetch		I	1 
TEST RANGE(i,0,1)
INIT result->write_hit_stop_readahead = i;

This specifies whether or not
the disk should discontinue the read-ahead of a previous request when a
write hit in the cache occurs.  Doing so allows the new write request's
data to begin travelling to the disk more quickly, at the expense of
some prefetching activity.

PARAM Read directly to buffer		I	1 
TEST RANGE(i,0,1)
INIT result->read_direct_to_buffer = i;

This specifies whether or not
space for a sector must be available in the buffer/cache prior to the
start of the sector read.  If false~(0), a separate sector buffer is assumed
to be available for use by the media-reading electronics, implying that the
data for a sector is transferred to the main buffer/cache only after it has
been completely read (and any error-correction algorithms completed).


PARAM Immed transfer partial hit	I	1 
TEST RANGE(i,0,1)
INIT result->immedtrans_any_readhit = i;

This specifies whether or not a read request whose initial (but not all)
data are present in the disk buffer/cache has that data immediately
transferred over the bus.  If false~(0), the data are immediately
transferred only if the amount of requested data that are present in
the buffer/cache exceed the {\it high water mark} (see above).

PARAM Read hit over. after read		D	1 
TEST d >= 0.0
INIT result->overhead_command_readhit_afterread = d;

This specifies the processing time for a read request that hits in the
on-board cache when the immediately previous request was also a read.
This delay is applied before any data are transferred from the disk
buffer/cache.

PARAM Read hit over. after write	D	1 
TEST d >= 0.0
INIT result->overhead_command_readhit_afterwrite = d;

This specifies the processing time for a read request that hits in the
on-board cache when the immediately previous request was a write.
This delay is applied before any data are transferred from the disk
buffer/cache.

PARAM Read miss over. after read	D	1 
TEST d >= 0.0
INIT result->overhead_command_readmiss_afterread = d;

This specifies the processing time for a read request that misses in the
on-board cache when the immediately previous request was also a read.
This delay is applied before any mechanical positioning delays or data
transfer from the media.


PARAM Read miss over. after write	D	1 
TEST d >= 0.0
INIT result->overhead_command_readmiss_afterwrite = d;

This specifies the processing time for a read request that misses in the
on-board cache when the immediately previous request was a write.
This delay is applied before any mechanical positioning delays or data
transfer from the media.


PARAM Write hit over. after read	D	1 
TEST d >= 0.0
INIT result->overhead_command_writehit_afterread = d;

This specifies the processing time for a write request that ``hits'' in
the on-board cache (i.e., completion will be reported before data
reaches media) when the immediately previous request was a read.  This
delay is applied before any mechanical positioning delays and before
any data are transferred to the disk buffer/cache.

PARAM Write hit over. after write	D	1 
TEST d >= 0.0
INIT result->overhead_command_writehit_afterwrite = d;

This specifies the processing time for a write request that ``hits'' in
the on-board cache (i.e., completion will be reported before data
reaches media) when the immediately previous request was also a write.
This delay is applied before any mechanical positioning delays and
before any data are transferred to the disk buffer/cache.

PARAM Write miss over. after read	D	1 
TEST d >= 0.0
INIT result->overhead_command_writemiss_afterread = d;

This specifies that ``misses'' in the on-board cache (i.e., completion will
be reported only after data reaches media) when the immediately
previous request was a read.  This delay is applied before any
mechanical positioning delays and before any data are transferred to
the disk buffer/cache.


PARAM Write miss over. after write	D	1 
TEST d >= 0.0
INIT result->overhead_command_writemiss_afterwrite = d;

This specifies the processing time for a write request that ``misses'' in
the on-board cache (i.e., completion will be reported only after data
reaches media) when the immediately previous request was also a write.
This delay is applied before any mechanical positioning delays and
before any data are transferred to the disk buffer/cache.

PARAM Read completion overhead		D	1 
TEST d >= 0.0
INIT result->overhead_complete_read = d;

This specifies the processing time for completing a read request.
This overhead is applied just before the completion message is sent
over the (previously acquired) bus and occurs in parallel with any
background disk activity (e.g.,~prefetching or preseeking).

PARAM Write completion overhead		D	1 
TEST d >= 0.0
INIT result->overhead_complete_write = d;

This specifies the processing time for completing a write request.
This overhead is applied just before the completion message is sent
over the (previously acquired) bus and occurs in parallel with any
background disk activity (e.g.,~preseeking).

PARAM Data preparation overhead		D	1 
TEST d >= 0.0
INIT result->overhead_data_prep = d;

This specifies the additional processing time necessary when preparing to
transfer data over the bus (for either reads or writes).  This command
processing overhead is applied after obtaining access to the bus
(prior to transferring any data) and occurs in parallel with any
ongoing media access.

PARAM First reselect overhead		D	1 
TEST d >= 0.0
INIT result->overhead_reselect_first = d; 

This specifies the processing time for reconnecting to (or
``reselecting'') the controller for the first time during the current
request.\footnote{Reselection implies that the disk has explicitly
disconnected from the bus at some previous point while servicing the
current request and is now attempting to reestablish communication
with the controller.  Disconnection and subsequent reselection result
in some additional command processing and protocol overhead, but they
may also improve the overall utilization of bus resources shared by
multiple disks (or other peripherals).}  This command processing
overhead is applied after the disk determines that reselection is
appropriate (prior to attempting to acquire the bus) and occurs in
parallel with any ongoing media access.

PARAM Other reselect overhead		D	1 
TEST d >= 0.0
INIT result->overhead_reselect_other = d;

This specifies the processing time for reconnecting to the controller
after the first time during the current request (i.e.,~the second
reselection, the third reselection, etc.).  This command processing
overhead is applied after the disk determines that reselection is
appropriate (prior to attempting to acquire the bus) and occurs in
parallel with any ongoing media access.


PARAM Read disconnect afterread		D	1 
TEST d >= 0.0
INIT result->overhead_disconnect_read_afterread = d;

This specifies the processing time for a read request that disconnects
from the bus when the previous request was also a read.  This command
processing overhead is applied after the disk determines that
disconnection is appropriate (prior to requesting disconnection from
the bus) and occurs in parallel with any ongoing media access.

PARAM Read disconnect afterwrite	D	1 
TEST d >= 0.0
INIT result->overhead_disconnect_read_afterwrite = d;

This specifies the processing time for a read request that disconnects
from the bus when the previous request was a write request.  This
command processing overhead is applied after the disk determines that
disconnection is appropriate (prior to requesting disconnection from
the bus) and occurs in parallel with any ongoing media access.

PARAM Write disconnect overhead		D	1 
TEST d >= 0.0
INIT result->overhead_disconnect_write = d;

This specifies the processing time for a write request that disconnects
from the bus (which generally occurs after the data are transferred
from the host to the on-board buffer/cache).  This command processing
overhead is applied after the disk determines that disconnection is
appropriate (prior to requesting disconnection from the bus) and
occurs in parallel with any ongoing media access.

PARAM Extra write disconnect		I	1 
TEST RANGE(i,0,1)
INIT result->extra_write_disconnect = i;

This specifies whether or not the disk disconnects from the bus after
processing the write command but before any data have been transferred
over the bus into the disk buffer/cache.  Although there are no
performance or reliability advantages to this behavior, it has been
observed in at least one production SCSI disk and has therefore been
included in DiskSim.  If true~(1), the next five parameters configure
additional overhead values specifically related to this behavior.


PARAM Extradisc command overhead	D	1 
TEST d >= 0.0
INIT result->extradisc_command = d;

This specifies the processing time for a write request that disconnects
from the bus before transferring any data to the disk buffer/cache.
This overhead is applied before requesting disconnection from the bus
and before any mechanical positioning delays.  This parameter (when
enabled) functions in place of the above ``Write over.'' parameters.

PARAM Extradisc disconnect overhead	D	1 
TEST d >= 0.0
INIT result->extradisc_disconnect1 = d;

This specifies the additional processing time for a write request that
disconnects from the bus before transferring any data to the disk
buffer/cache.  This overhead is also applied before requesting
disconnection from the bus, but it occurs in parallel with any
mechanical positioning delays.  This parameter (when enabled)
functions in place of the above ``Write disconnect'' parameter for
initial write disconnections.


PARAM Extradisc inter-disconnect delay	D	1 
TEST d >= 0.0
INIT result->extradisc_inter_disconnect = d;

This specifies the time between the initial disconnect from the bus and
the subsequent reconnection attempt for a write request that
disconnects from the bus before transferring any data to the disk
buffer/cache.  It occurs in parallel with any mechanical positioning
delays.

PARAM Extradisc 2nd disconnect overhead	D	1 
TEST d >= 0.0
INIT result->extradisc_disconnect2 = d; 

This specifies the processing time for a write request that disconnects
from the bus after data has been transferred but previously had
disconnected without transferring any data to the disk buffer/cache.
This command processing overhead is applied after the disk determines
that disconnection is appropriate (prior to requesting disconnection
from the bus) and occurs in parallel with any ongoing media access.
This parameter (when enabled) functions in place of the above ``Write
disconnect'' parameter for non-initial write disconnections.

# not used by mech model
PARAM Extradisc seek delta		D	1 
TEST d >= 0.0
INIT result->extradisc_seekdelta = d;

This specifies the additional delay between the completion of the initial
command processing overhead and the initiation of any mechanical
positioning for a write request that disconnects from the bus before
transferring any data to the disk buffer/cache.  This delay occurs in
parallel with ongoing bus activity and related processing overheads.

# not used by mech model
PARAM Minimum seek delay		D	1 
TEST d >= 0.0
INIT result->minimum_seek_delay = d;

This specifies the minimum media access delay for a nonsequential write
request.  That is, a nonsequential write request (after any command
processing overheads) must wait at least this amount of time before
accessing the disk media.


PARAM Immediate buffer read		I	1 
TEST RANGE(i,0,2)
INIT result->immedread = i;

This specifies whether or not disk sectors should be transferred into the
on-board buffer in the order that they pass under the read/write head
rather than in strictly ascending logical block order.  This is known
as {\it zero-latency reads} or {\it read-on-arrival}.  It is intended
to improve response times by reducing rotational latency (by not
rotating all the way around to the first requested sector before
beginning to fill the buffer/cache).

PARAM Immediate buffer write		I	1 
TEST RANGE(i,0,2)
INIT result->immedwrite = i;

This specifies whether or not disk sectors should be transferred from the
on-board buffer in the order that they pass under the read/write head
rather than in strictly ascending logical block order.  These are known
as {\it zero-latency writes} or {\it write-on-arrival}.  It is
intended to improve response times by reducing rotational latency (by
not rotating all the way around to the first ``dirty'' sector before
beginning to flush the buffer/cache).