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

Despite a low 26% Hit Ratio, swap-in requests constitute more than 50% of swapping activity. The number of swap-out requests is approximately the number of cachable misses. The number of swap-in requests is approximately the number of non-304 hits. Finally, the number of non-cachable documents is much higher than the number of 304 hits. The latter favors swap-in requests.

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

For this server, in 50% of cases, a swap request will compete with up to 6 other requests. In 75% of cases, there may be us much as 14 requests to compete with during peak load.

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.

During peak load, disk utilization is close to 100%. This means longer disk queues and, consequently long delays in response time (see also proxy and disk response time figures). This disk utilization is too high; to the proxy server must be upgraded with additional disks.

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 graph shows what happens to disk response time when disk utilization is very high. Note a 9 fold increase in response time during peak load and 3 fold increase during first "aftershock" around 13:30. These increases correspond to peaks of disk utilization at 93% and 79%.

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 fewer files of that size; also disk and network delays in-between disk I/Os may spoil the picture.

Clearly, the duration of the first delay should be the same for any file size. However, on our graph swap-in requests do not follow this rule (first delay is smaller for files bigger than 8 KB) due to a performance bug in Squid described elsewhere. We silently adjust for this bug in calculations for swap-in requests. Swap-out requests need no adjustment.

We summarized our calculations for 24 hours in a table (all times are medians in milliseconds). Unfortunately, due to severe disk bottleneck we cannot get reliable numbers for peak load -- high variation in disk delays in-between individual I/Os makes calculations unaccurate.

	24 Hours
	I/O	Overhead
Swap In	36	38
Swap Out	30	34

Note that these figures differ substantially from the ones obtained from the ruu.nl proxy server. We are currently investigating the source of this difference.

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, 16Kb]. 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). Again, we adjust for the bug with swap-in requests.

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.