Examples of using CSRIRP to define a reference pattern

To clarify the relationships between the unitsize, gapsize, and units parameters, this topic contains three examples of defining a reference pattern. So that you can compare the three examples with what the system does without information from CSRIRP, the following call approximates the system’s normal paging operation:

CSRIRP with unitsize of 4096 bytes
            gapsize of 0 bytes
            units of 1 reference unit (that is, one page)

Each time the system takes a page fault, it brings in 4096 bytes (one page), the system’s reference unit. It brings in one reference unit at a time.

Example 1 The program processes all elements in an array in a forward direction. The processing of each element is fairly simple. The program runs during the peak hours, and many programs compete for processor time and central storage. A reasonable value to choose for the number of bytes to come into central on a page fault might be 80000 bytes (around 20 pages); unitsize can be 4000 bytes and units can be 20. The following CSRIRP service communicates this pattern to the system:

CSRIRP with unitsize of 4000 bytes
            gapsize of 0 bytes
            units of 20
            direction of +1

Example 2 The program performs the same process as in Example 1, except the program does not reference every element in the array. The program runs during the night hours when contention for the processor and for central storage is light. In this case, a reasonable value to choose for the number of bytes to come into central storage on a page fault might be 200000 bytes (around 50 pages). unitsize can again be 4000 bytes and units can be 50. The following CSRIRP service communicates this pattern:

CSRIRP with unitsize of 4000 bytes
            gapsize of 0 bytes
            units of 50
            direction of +1

Example 3 The program references in a consistently forward direction through the same large array. The pattern of reference in this example includes a gap. The program references 8192 bytes, then skips the next 4096 bytes, references the next 8192 bytes, skips the next 4096 bytes throughout the array. The program chooses to bring in data 8 pages at a time. Because of the placement of reference units and gaps on page boundaries, the system does not bring in the data in the gaps.

The following CSRIRP service reflects this reference pattern:

CSRIRP with unitsize of 4096*2 bytes
            gapsize of 4096 bytes
            units of 4
            direction of +1

where the system is to bring into central storage 8 pages (4×4096×2 bytes) on a page fault. The system’s response to CSRIRP is illustrated as follows: