disk.modspec

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

# DiskSim Storage Subsystem Simulation Environment (Version 3.0)
# Revision Authors: John Bucy, Greg Ganger
# Contributors: John Griffin, Jiri Schindler, Steve Schlosser
#
# Copyright (c) of Carnegie Mellon University, 2001, 2002, 2003.
#
# This software is being provided by the copyright holders under the
# following license. By obtaining, using and/or copying this software,
# you agree that you have read, understood, and will comply with the
# following terms and conditions:
#
# Permission to reproduce, use, and prepare derivative works of this
# software is granted provided the copyright and "No Warranty" statements
# are included with all reproductions and derivative works and associated
# documentation. This software may also be redistributed without charge
# provided that the copyright and "No Warranty" statements are included
# in all redistributions.
#
# NO WARRANTY. THIS SOFTWARE IS FURNISHED ON AN "AS IS" BASIS.
# CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITHER
# EXPRESSED OR IMPLIED AS TO THE MATTER INCLUDING, BUT NOT LIMITED
# TO: WARRANTY OF FITNESS FOR PURPOSE OR MERCHANTABILITY, EXCLUSIVITY
# OF RESULTS OR RESULTS OBTAINED FROM USE OF THIS SOFTWARE. CARNEGIE
# MELLON UNIVERSITY DOES NOT MAKE ANY WARRANTY OF ANY KIND WITH RESPECT
# TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
# COPYRIGHT HOLDERS WILL BEAR NO LIABILITY FOR ANY USE OF THIS SOFTWARE
# OR DOCUMENTATION.




MODULE disk
PROTO struct disk *disksim_disk_loadparams(struct lp_block *b, int *num);

PARAM Model				BLOCK	1
TEST result->model = dm_disk_loadparams(blk, 0)

Parameters for the disk's libdiskmodel model.  See the diskmodel
documentation for details.


PARAM Scheduler				BLOCK	1 
TEST (result->queue = (struct ioq *)disksim_ioqueue_loadparams(blk, device_printqueuestats, device_printcritstats, device_printidlestats, device_printintarrstats, device_printsizestats))
# INIT ioqueue_initialize(result->queue, 0);
An ioqueue; see Section \ref{param.queue}

PARAM Max queue length			I	1 
TEST i >= 0
INIT result->maxqlen = i;

This specifies the maximum number of requests that the disk can have in
service or queued for service at any point in time.  During
initialization, other components request this information and respect
it during simulation.

PARAM Bulk sector transfer time		D	1 
TEST  d >= 0.0
INIT result->blktranstime = d;

This specifies the time for the disk to transfer a single 512-byte block
over the bus.  Recall that this value is compared with the
corresponding bus and controller block transfer values to determine
the actual transfer time (i.e.,~the maximum of the three values).

PARAM Segment size (in blks)		I	1 
TEST RANGE(i, 1, result->model->dm_sectors)
INIT result->segsize = i;

This specifies the size of each buffer segment, assuming a static segment
size.  Some modern disks will dynamically resize their buffer segments
(and thereby alter the number of segments) to respond to perceived
patterns of workload behavior, but DiskSim does not currently support
this functionality.

PARAM Number of buffer segments		I	1 
TEST i >= 0
INIT result->numsegs = i;

This specifies the number of segments in the on-board buffer/cache.  A
buffer segment is similar to a cache line, in that each segment
contains data that is disjoint from all other segments.  However,
segments tend to be organized as circular queues of logically
sequential disk sectors, with new sectors pushed into an appropriate
queue either from the bus (during a write) or from the disk media
(during a read).  As data are read from the buffer/cache and either
transferred over the bus (during a read) or written to the disk media
(during a write), they are eligible to be pushed out of the segment
(if necessary or according to the dictates of the buffer/cache
management algorithm).


PARAM Print stats			I	1 
TEST RANGE(i,0,1)
INIT result->printstats = i;
This specifies whether or not statistics for the disk will be reported.


PARAM Per-request overhead time		D	1 
TEST d >= 0.0
INIT result->overhead = d;
This specifies a per-request processing overhead that takes place
immediately after the arrival of a new request at the disk.  It is
additive with various other processing overheads described below, but
in general either the other overheads are set to zero or this
parameter is set to zero.


PARAM Time scale for overheads		D	1 
TEST d >= 0.0
INIT result->timescale = d;
This specifies a multiplicative scaling factor for all processing overhead
times.  For example, 0.0 eliminates all such delays, 1.0 uses them at
face value, and 1.5 increases them all by 50\%.

PARAM Hold bus entire read xfer		I	1 
TEST RANGE(i,0,1)
INIT result->hold_bus_for_whole_read_xfer = i;

This specifies whether or not the disk retains ownership of the bus
throughout the entire transfer of ``read'' data from the disk.  If
false~(0), the disk may release the bus if and when the current
transfer has exhausted all of the available data in the on-board
buffer/cache and must wait for additional data sectors to be read off
the disk into the buffer/cache.


PARAM Hold bus entire write xfer	I	1 
TEST RANGE(i,0,1)
INIT result->hold_bus_for_whole_write_xfer = i;

This specifies whether or not the disk retains ownership of the bus
throughout the entire transfer of ``write'' data to the disk.  If
false~(0), the disk may release the bus if and when the current
transfer has filled up the available space in the on-board
buffer/cache and must wait for data from the buffer/cache to be
written to the disk.


PARAM Allow almost read hits	I		1 
TEST RANGE(i,0,1)
INIT result->almostreadhits = i;

This specifies whether or not a new read request whose first block is
currently being prefetched should be treated as a partial cache hit.
Doing so generally means that the request is handled right away.


PARAM Allow sneaky full read hits	I	1 
TEST RANGE(i,0,1)
INIT result->sneakyfullreadhits = i;

This specifies whether or not a new read request whose data are entirely
contained in a single segment of the disk cache is allowed to
immediately transfer that data over the bus while another request is
moving the disk actuator and/or transferring data between the disk
cache and the disk media.  In essence, the new read request ``sneaks''
its data out from the disk cache without interrupting the current
(active) disk request.


PARAM Allow sneaky partial read hits	I	1 
TEST RANGE(i,0,1)
INIT result->sneakypartialreadhits = i;

This specifies whether or not a new read request whose data are partially
contained in a single segment of the disk cache is allowed to
immediately transfer that data over the bus while another request is
moving the disk actuator and/or transferring data between the disk
cache and the disk media.  In essence, the new read request ``sneaks''
the cached portion of its data out from the disk cache without
interrupting the current (active) disk request.


PARAM Allow sneaky intermediate read hits	I	1 
TEST RANGE(i,0,1)
INIT result->sneakyintermediatereadhits = i;

This specifies whether or not the on-board queue of requests is searched
during idle bus periods in order to find read requests that may be
partially or completely serviced from the current contents of the disk
cache.  That is, if the current (active) request does not need bus
access at the current time, and the bus is available for use, a queued
read request whose data are in the cache may obtain access to the bus
and begin data transfer.  ``Full'' intermediate read hits are given
precedence over ``partial'' intermediate read hits.


PARAM Allow read hits on write data	I	1 
TEST RANGE(i,0,1)
INIT result->readhitsonwritedata = i;

This specifies whether or not data placed in the disk cache by write
requests are considered usable by read requests.  If false~(0), such
data are removed from the cache as soon as they have been copied to
the media.

PARAM Allow write prebuffering		I	1 
TEST RANGE(i,0,1)
INIT result->writeprebuffering = i;

This specifies whether or not the on-board queue of requests is searched
during idle bus periods for write requests that could have part or all
of their data transferred to the on-board cache (without disturbing an
ongoing request).  That is, if the current (active) request does not
need bus access at the current time, and the bus is available for use,
a queued write request may obtain access to the bus and begin data
transfer into an appropriate cache segment.  Writes that are
contiguous to the end of the current (active) request are given
highest priority in order to facilitate continuous transfer to the
media, followed by writes that have already ``prebuffered'' some
portion of their data.


PARAM Preseeking level			I	1 
TEST RANGE(i,0,2)
INIT result->preseeking = i;

This specifies how soon the actuator is allowed to start seeking towards
the media location of the next request's data.  

0~indicates no preseeking, meaning that the actuator does not begin
relocation until the current request's completion has been confirmed
by the controller (via a completion ``handshake'' over the bus).

1~indicates that the actuator can begin relocation as soon as the
completion message has been prepared for transmission by the disk.

2~indicates that the actuator can begin relocation as soon as the
access of the last sector of the current request (and any required
prefetching) has been completed.  This allows greater parallelism
between bus activity and mechanical activity.


PARAM Never disconnect			I	1 
TEST RANGE(i,0,1)
INIT result->neverdisconnect = i;

This specifies whether or not the disk retains ownership of the bus during
the entire processing and servicing of a request (i.e.,~from arrival
to completion).  If false~(0), the disk may release the bus whenever
it is not needed for transferring data or control information.

PARAM Avg sectors per cylinder		I	1 
TEST RANGE(i,1,result->model->dm_sectors)
INIT result->sectpercyl = i;

This specifies (an approximation of) the mean number of sectors per
cylinder.  This value is exported to any external
schedulers\footnote{Some scheduling algorithms available in DiskSim
utilize approximations of the actual layout of data on the disk(s)
when reordering disk requests.} requesting it and is not used by the
disk itself.

PARAM Maximum number of write segments	I	1 
DEPEND Number of buffer segments
TEST RANGE(i,1,result->numsegs)
INIT result->numwritesegs = i;

This specifies the number of cache segments available for holding
``write'' data at any point in time.  Because write-back caching is
typically quite limited in current disk cache management schemes, some
caches only allow a subset of the segments to be used to hold data for
write requests (in order to minimize any interference with sequential
read streams).

PARAM Use separate write segment	I	1 
TEST RANGE(i,0,1)
# WTF?!
INIT result->dedicatedwriteseg = (segment *)i;

This specifies whether or not a single segment is statically designated
for use by all write requests.  This further minimizes the impact of
write requests on the caching/prefetching of sequential read streams.

PARAM Low (write) water mark		D	1 
TEST RANGE(d,0.0,1.0)
INIT result->writewater = d;

This specifies the fraction of segment size or request size (see below)
corresponding to the {\it low water mark}.  When data for a write
request are being transferred over the bus into the buffer/cache, and
the buffer/cache segment fills up with ``dirty'' data, the disk may
disconnect from the bus while the buffered data are written to the
disk media.  When the amount of dirty data in the cache falls below
the low water mark, the disk attempts to reconnect to the bus to
continue the interrupted data transfer.

PARAM High (read) water mark		D	1 
TEST RANGE(d,0.0,1.0)
INIT result->readwater = d;

This specifies the fraction of 
segment size or request size (see below) corresponding to the 
{\it high water mark}.  When data for a read request are being transferred
over the bus from the buffer/cache, and the buffer/cache segment runs out of
data to transfer, the disk may disconnect from the bus until additional data
are read from the disk media.  When the amount of available data in the cache 
reaches the high water mark, the disk attempts to reconnect to the bus to 
continue the interrupted data transfer.


PARAM Set watermark by reqsize		I	1 
TEST RANGE(i,0,1)
INIT result->reqwater = i;

This specifies whether the 
watermarks are computed as fractions of the individual request size
or as fractions of the buffer/cache segment size.


PARAM Calc sector by sector		I	1 
TEST RANGE(i,0,1)
INIT result->sectbysect = i;

This specifies whether or not media transfers should be computed sector by
sector rather than in groups of sectors.  This optimization has no
effect on simulation accuracy, but potentially results in shorter
simulation times (at a cost of increased code complexity).  It has not
been re-enabled since the most recent modifications to DiskSim, so the
simulator currently functions as if the value were always true~(1).

PARAM Enable caching in buffer		I	1 
TEST RANGE(i,0,2)
INIT result->enablecache = i;

This specifies whether or not
on-board buffer segments are used for data caching as well as for
speed-matching between the bus and the disk media.  Most (if not all) modern 
disk drives utilize their buffers as caches.

PARAM Buffer continuous read		I	1 
TEST RANGE(i,0,4)
INIT result->contread = i;

This specifies the type of prefetching performed by the disk.  0~disables
prefetching.  1~enables prefetching up to the end of the track
containing the last sector of the read request. 2~enables prefetching
up to the end of the cylinder containing the last sector of the read
request. 3~enables prefetching up to the point that the current cache
segment is full.  4~enables prefetching up to the end of the track
following the track containing the last sector of the read request,
provided that the current request was preceded in the not-too-distant
past by another read request that accessed the immediately previous
track.  In essence, the last scheme enables a type of prefetching that
tries to stay one logical track ``ahead'' of any sequential read
streams that are detected.

PARAM Minimum read-ahead (blks)		I	1 
TEST RANGE(i,0,result->segsize)
INIT result->minreadahead = i;

This specifies the minimum number of disk sectors that must be prefetched
after a read request before servicing another (read or write) request.
A positive value may be beneficial for workloads containing multiple
interleaved sequential read streams, but 0~is typically the
appropriate value.

PARAM Maximum read-ahead (blks)		I	1 
TEST RANGE(i,0,result->segsize)
INIT result->maxreadahead = i;

This specifies the maximum number of disk sectors that may be prefetched
after a read request (regardless of all other prefetch parameters).


PARAM Read-ahead over requested		I	1 
TEST RANGE(i,-1,1)
INIT result->keeprequestdata = i;

This specifies whether or not newly prefetched data can replace (in a
buffer segment) data returned to the host as part of the most recent
read request.  
% If false~(0), prefetch is %terminated when the buffer segment is
% full.

PARAM Read-ahead on idle hit		I	1 
TEST RANGE(i,0,1)