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).

The graph implies that there is no competition for disk resources. At least in 75%, there was no disk requests at all.

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 3 blocks (24 KB) are not distinct: There are not enough files of that size to get a "stable" median; also disk and network delays in-between disk I/Os may spoil the picture.

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

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

	24 Hours
	I/O	Overhead
Swap In	22	20

Our model apparently does not apply to swap-out requests. One page swap-out requires about 36 msec. However, two page swap-out takes about 106 msec (38 and 118 msec during peak load). We cannot explain such poor performance of swap-out requests. Looks like there is a significant extra delay (other than file open overhead from our model) for two page documents that does not exist for one page documents.

We also failed to get reliable figures for swap-in requests during peak load: One page swap-in takes about 48 msec while two page swap-in requires about 90 msec.

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.