The graph shows the speed of processing swap-in and swap-out requests during the day (in requests per second).

The graph shows the number of concurrent swap requests present in the proxy server. We count the number of requests in the system using 2 msec intervals and calculate the median based on 20 minute grouping. Small 2 msec intervals assure that we count the number of concurrent requests rather than total number of requests per [large] interval. Note that this graph is not a "disk request per second" graph.

We plot the 50th and 75th percentiles. The 50th percentile is the same as median.

This graph is useful in determining the increase in the length of disk queues during peak hours (if any).

Disk utilization is measured in the percent of time there was at least one active swap request. The measurements are done using 2 msec intervals. Note that only swap requests are taken into consideration. Disk utilization is represented by the "all" curve. Curves for swap-in and swap-out requests are given to compare the contribution of each class towards disk utilization.

The patch does not measure per disk utilization. The graph represents the utilization of the disk I/O subsystem as a whole. In other words, if there is always one disk I/O in the system, then utilization is 100% regardless of the number of physical disks installed.

Disk response time is the total time it takes to load/store (swap in/out) a document from/into the disk cache. The graph shows median disk response time in milliseconds during the day.

The patch allows for quantifying varios I/O delays. Let's consider a swap request. Swapping a document is done in several steps. First, the corresponding file should be opened for reading or created for writing. This requires an open(2) system call which may incur significant OS overhead: An open(2) call may result in extra I/Os if OS has to write/read i-nodes to/from disk. Then the content in swapped to/from disk using blocks of fixed size. Disk cache and various delays in-between these I/Os affect the total response time.

To estimate the OS overhead on swapping a file we plot the median disk response time of a request versus file size. Response times for files smaller than 16 KB were grouped using 1 KB granularity. Larger files used 1 KB granularity to get enough entries per group. The graph is based on the 24 hour data.

Squid attempts to swap files using blocks of fixed length (e.g. 8 KB). For each I/O direction, we plot the total request response time and the time it takes to swap the first block. The "total" and "1st delay" curves for files smaller than 8 KB are the same.

Since various per I/O delays dominate disk transfer time, the size of an I/O is not very important (the number of I/Os is). This explains step-like shape of the "total" curves: If I/O block size is 8 KB, the times to read 5 KB and 8 KB are the same!

The first disk delay always includes OS overhead on opening a file. Consecutive I/Os for the same file (if any) do not have this overhead. Thus, for file sizes equal to two I/O blocks (16 KB), the difference between the first delay and second I/O approximates OS overhead on opening a file. The patch does not measure the duration of the second I/O. However, we can compute it, assuming that overhead does not depend on the file size for small files:

    1st_Delay   = Overhead + I/O
    Total( 8KB) = 1s_Delay
    Total(16KB) = 1s_Delay + I/O
 =>
    I/O      = Total(16KB) - Total( 8KB)
    Overhead = Total( 8KB) - I/O

Note that the first "step" on each "total" curve corresponds to the size of the Squid I/O block for this server (8 KB). "Steps" for requests larger than 4 blocks (32 KB) are not distinct: Disk and network delays in-between disk I/Os may spoil the picture.

The duration of the first delay is the same for any file size (the "double-read(2)" bug is fixed).

We summarized our calculations for 24 hours in a table (all times are medians in milliseconds).

	24 Hours
	I/O	Overhead
Swap In	92	28
Swap Out	70	40

Reads are 22 msec slower than writes. Swap-out overhead is larger than swap-in overhead.

Faster 70 msec swap-out I/Os make multi-page swap-outs faster than swap-ins despite larger OS overhead for swap-out requests. Compared to swap-ins, swap-out requests pay big one time "subscription fee" but small "monthly payments". This saves them "money" on the long run.

The increase in I/O duration with load may be caused by longer queuing delays of individual disk requests. Note that these are per I/O delays and our computations account for them in the I/O cost. Currently, we do not have enough data to quantify these delays. However, we can show how I/O duration changes with load.

The graph is based on second I/O duration for 2 page files (8 KB, 16 KB]. The second I/O duration is calculated as a difference between total response time and the first delay (another method to approximate I/O duration which gives close results).

Note up to 5 fold increases in second I/O during peaks in proxy load. We were not able to apply our model to peak load.

It is tempting to improve the overall response time by pipelining disk and network transfers. The graph studies the percentage of atomic swap requests. An atomic requests is served using a single disk I/O. Thus, there is no opportunity for a cache server to pipeline the processing of an atomic request.