Anomalies with Variable Partition Paging Algorithms

Transcription

1 1. Introduction Operating Systems R.S. Gaines Editor Anomalies with Variable Partition Paging Algorithms M. A. Franklin, Washington University G. Scott Graham, University of Toronto, and R. K. Gupta, Burroughs Corporation Five types of anomalous behaviour which may occur in paged virtual memory operating systems are def'med. One type of anomaly, for example, concerns the fact that, with certain reference strings and paging algorithms, an increase in mean memory allocation may result in an increase in fault rate. Two paging algorithms, the page fault frequency and working set algorithms, are examined in terms of their anomaly potential, and reference string examples of various anomalies are presented. Two paging algorithm properties, the inclusion property and the generalized inclusion property, are discussed and the anomaly implications of these properties presented. Key Words and Phrases: anomaly, memory management, program behavior, stack algorithms, virtual memory, working set, page fault frequency, paging algorithms CR Categories: 4.32, 4.35, 4.6, 8.1 General permission to make fair use in teaching or research of all or part of this material is granted to individual readers and to nonprofit libraries acting for them provided that ACM's copyright notice is given and that reference is made to the publication, to its date of issue, and to the fact that reprinting privileges were granted by permission of the Association for Computing Machinery. To otherwise reprint a figure, table, other substantial excerpt, or the entire work requires specific permission as does republication, or systematic or multiple reproduction. Author's addresses: M. A. Franklin, Department of Electrical Engineering, Washington University, St. Louis, MO 63130; G. S Graham, Computer Systems Research Group, University of Toronto, Toronto, Canada, M5S 1A4; R. K. Gupta, Burroughs Corp., FSSG GVL 3, Paoli, PA ACM /78/ $ In paged virtual memory computer systems [5], programs may be executed with only a part of their pages resident in main memory and with the remainder of them residing on auxiliary storage. Pages are moved between these two levels of storage during program execution. Under "demand paging" schemes, a page is transferred from auxiliary store to main memory only if a "page fault" occurs for that page. Page faults, and the associated movement of pages between main and auxiliary storage, take a period of time referred to as the page transfer time. This time can be considered to be an overhead cost which degrades system performance. One way to improve performance is based on the commonly held notion that a larger main memory allocation, and hence more resident pages, will result in fewer page faults. This has been shown, however, not to be always true. For example, certain experimental results obtained from the M44/44X paging system [1] are contrary to this notion. Belady et al. [1] have presented an analysis of such paging behavior for selected reference strings operating under the first-in first-out (FIFO) paging algorithm [2]. For certain cases an increase in allocated memory size actually increased the fault rate, thus exhibiting what is referred to as anomalous behavior. These experimental results and examples dealt with a fixed memory size allocation and the FIFO paging algorithm. In 1970 Mattson et al. [12] introduced a class of paging algorithms called "stack algorithms." These were reported to be anomaly free. Several wellknown paging algorithms, such as the least recently used, least frequently used, and optimal [12] replacement algorithms, have been shown to be stack algorithms and are anomaly free. Since then, several studies [3, 4, 6] have shown that in terms of overall systems performance, variable partition paging algorithms such as working set (WS) [7] and page fault frequency (PFF) [3] are superior to fixed partition paging algorithms. Recently, anomalous behavior has been observed for certain reference strings under these two paging algorithms. Anomalies in the behavior of PFF were discovered independently by the authors 1 in much the same way as the FIFO anomaly was discovered, by experimentation. The experiments involved [10, 11] are not of direct concern here; however, they relate to simulation of a virtual memory operating system using the PFF algorithm. Certain program reference strings exhibited the anomalous behavior which is reported here. Further analysis demonstrated that certain anomalous behavior is also possible for the WS algorithm. 1 Franklin and Gupta discovered the anomaly during the summer of 1974 and Graham discovered it during the summer of 1975.

2 2. The Anomaly A framework for considering anomalous behavior is presented in terms of certain properties discussed below. Violation of a property implies a particular kind of anomalous behavior. Our concern is with variable partition paging algorithms. Apart from locality prediction and ease of implementation, the following properties are desirable for a paging algorithm. PI: The page fault rate should be a nonincreasing function of mean memory allocation. Intuitively, an increase in memory allocation should not increase the execution time or number of page faults. That is, if ~/1 and /(/2 are two mean memory allocations and F1 and F2 are the associated number of faults for a given reference string, then/(/~ -</f/z ~ F1 ---F~. In this situation two types of anomalies can be distinguished on the basis of the following two measures of memory allocation: (a) Real time memory allocation-the mean amount of memory allocated across real time (i.e. virtual time plus page transfer time). (b) Virtual time memory allocation-the mean amount of memory allocated across the virtual time (i.e. real time minus page transfer time). To quantify this further, let M(t, p) denote the number of pages resident just following the reference at virtual time t, given that the paging algorithm is run with its parameter fixed at p. Let F(p) be the number of faults obtained with a given reference string of length K. The average virtual time memory allocation is thus given by K V(p) = (1//0 ~] M(t, p). t=l The average real time memory allocation is given by R(p) = (K. V(p) + L. S(p))/(K + F(p). L). where L is mean page transfer time and S(p) is the total of memory allocations over the page fault times. S(p) is computed by summing up the memory allocation sizes associated with each of the page faults. The two types of anomalies corresponding to real and virtual time memory allocations can now be defined. Assume that we are given a reference string and a page transfer time L. A real memory-fault rate anomaly exists if there are values of paging algorithm parameters p and q such that R(p) < R(q) and F(p) < F(q). Similarly a virtual memory-fault rate anomaly exists if there are values of paging algorithm parameters p and q such that V(p) < V(q) and F(p) < F(q). P2: Page fault rate should be a nonincreasing function of the paging algorithm parameter. Variable partition paging algorithms can effectively control system fault rate by adjusting the parameter only if the page fault rate function is well behaved. A parameter-fault rate anomaly exists if, for some p and q, p >q and F(p) > F(q). P3: Mean memory allocation should be a nondecreasing function of the paging algorithm parameter. Variable partition paging algorithms can effectively control memory allocation by adjusting the parameter only if the mean memory allocation function is well behaved. A parameter-real memory anomaly exists if, for somep and q, p >q and R(p) < R(q). Similarly a parameter-virtual memory anomaly exists if p >q and V(p) < V(q). 3. Anomalies with the PFF Algorithm: The PFF paging algorithm can be described in terms of an allocation and a replacement process [3]. The algorithm allocates a page each time there is a page fault. The algorithm replaces or removes one or more pages from memory at page fault time if the interfault interval exceeds a critical value T. Thus if tk denotes the virtual time at the kth page fault, the pages are removed only if tk > tk-1 + T. The pages removed at t~ are those pages not referenced during tk-1 <-- t <-- tk. It can be demonstrated that anomalous behavior is possible for the PFF paging algorithm, and all properties discussed above may be violated. This can be seen by examining the reference string example given in Figure 1. The reference string has eight different pages and is cyclic. The substring from virtual time period 3 to 37 repeats cyclically, as do the memory contents. The memory contents after each reference are shown for two cases which have PFF parameter T = 4 and 6, respectively. The circle marks indicate page faults, while the double circle marks indicate page faults with replacement of pages. For the reference period 1 to 37 the number of faults, and virtual and real time memory allocations, are shown in Table I. Note the following inequalities for the mean real time memory allocation: L 1 = < < lll L and L 1 = > L L These inequalities hold for all values of L. Thus, for T values 4 and 6, all three performance measures listed in the table have increased. This reference string thus 233

3 Fig. 1. Reference string for anomalous PFF behavior. Virtual time I !) Reference string Memorycon- 1. (~)@Q tents for T = Memoryeon-1. OQ(~ Q tents for T = @ Q Table 1. Performance Measures for the Reference String of Figure 1. PFF parameter Performance Measures T = 4 T = 6 Number of faults F(T) l Mean virtual time mem- V(T) ory allocation Mean real time memory R(T) L L allocation 37 +lll L exhibits the real memory-fault rate anomaly, the virtual memory-fault rate anomaly, and the parameter-fault rate anomaly. Another reference string is given in Figure 2. It is 36 references long, and memory contents for T = 5 and 7 are shown. Table II, shows the performance measures for this reference string. It can be shown that this string exhibits the real memory-fault rate, virtual memory-fault rate, parameter-real memory, and parameter-virtual memory anomalies. Anomalous behavior under the PFF paging algorithm occurs when an increase in T results in inactive pages being kept in memory for a longer time than necessary and then paged out just before they are referenced again. For instance, in Figure 1, for T = 6, pages 5, 6, and 2 are kept in memory for virtual times though they are not referenced. They are then paged out at time 18 just before they are again referenced. Allocation size as well as fault rate thus may both increase with increasing T. A different kind of reference behavior is shown in Figure 2. In this case interfault intervals shorter than the threshold window T do not allow removal of pages and thus keep V(T) and R(T) high. An increase in T allows page removals at time 16 but also removes page faults at time 12. This kind of reference string also produces anomalous behavior Anomalies with the WS Algorithm The working set paging algorithm keeps in memory pages referenced during the previous T references, where T is a constant value [7]. This set of pages is called the working set and, at time t, is denoted by W(t, T). The mean working set size is the mean number of pages in the working set of pages and is denoted by Given a WS paging algorithm with T, W(t, T), and w(z) as defined above, for T1 < T2 [8], W(t, T1) C_ W(t, T2) and W(T~) <-- W(Z2). Thus the set of pages for window size TI is always contained in the set of pages for window size T2, and therefore the fault rate is a nonincreasing function of T (i.e. it satisfies P2). An increase in the working set size is possible only if T is increased, and thus the fault rate will not be increased by increasing mean virtual time memory allocation. WS will therefore not exhibit the virtual memory-fault rate, the parameter-fault rate, or the parameter-virtual memory, anomalies. It does, however, show the real memory-fault rate and parameter-real memory anomalies for some reference strings. One such reference string is given in Figure 3, and its related performance measures are given in Table III. Note that the increase in T has decreased the number of faults and increased the mean virtual memory allocation (i.e. working set size). The real time memory allocation for T = 4 and z = 5 has changed from ( L)/( L) to ( L)/(13 + 4L), and therefore for large L the real time allocation has decreased from 3.7 to 3.5. This decrease in allocation size along with the decrease in number of faults constitutes a real memory-fault rate anomaly and a parameter-real memory anomaly. Note that the average real time memory allocation is given by the following equation: R(T) = (K. V(T) + L. S(T))/(K + L" F(T)).

4 Fig. 2. Second reference string for anomalous PFF behavior. Virtual time Reference string Memory contents (T) (~) O O~) fort= Memory (~) O 4 for T = ' ' 4 " 1 " ' 3 Fig. 3. Reference string for anomalous WS behavior. Virtual time Reference string '4, Memory @ (~) 1 1 for T = Memory contents 1 (~) (~) (~) (~) for r = Table II. Performance Measures for the Reference String of Figure 2. PFF parameter Table III. Performance Measures for the Reference String of Figure 3. WS parameter Performance measures T = 5 T = 7 Performance measures ~- = 4 z = 5 Number of faults F(T) 5 4 Number of faults F(~') 10 4 Virtual time memory al- V(T) Virtual time memory al- V(z) 43/13 53/13 location location Real time memory allo- R(T) L L Real time memory allo- R(T) L L cation L L cation L L Now S(z)/F(T) is the average memory allocation at fault instances Increasing the working set parameter from T to T* increases V(T) to V(z*) and decreases the number of faults from F(T) to F(T*). If the average memory allocation at those faults which are removed by the increase in ~" is larger than S(T)/F(T), the following condition may exist: S(T*)/F(T*) < S(T)/F(T). For large L, this condition will produce the parameterreal memory anomaly In fact, for such cases there exists a crossover point L = Lc such that L > Lc implies R(T) > R(T*). The reference string example of Figure 3 exhibits this pattern In this case the average memory allocation at removed faults is 4, which is larger than 37/10 S(4)/F(4) = 3.7 and S(5)/F(5) = 3.5. For this case the crossover value of L is Note that the crossover value may be different for some other reference string and pair of T'S Inclusion Property and the Question of Anomalies The stack algorithms introduced by Mattson et al.. [12] follow the inclusion property (IP): At any time t, the set of pages in an allocated memory of size c is also contained in memory of size c* where c* > c. Note that memory allocation may be controlled by the paging algorithm. For a fixed partition stack algorithm, the memory size is that fixed maximum number of pages which a program may utilize during execution For such algorithms none of the anomalies mentioned earlier exists A similar behavioral discipline which applies to variable partition paging algorithms and which may ensure anomaly-free behavior is needed The generalized inclusion property (GIP) given next is a step in this direction

5 At any time t, the set of pages in memory for algorithm parameter p is also contained in memory for algorithm parameter p* where p* > p. Therefore ~t, Pl < pz --* B(t, Pl) C_ B(t, P2) where B(t, p) is the set of resident pages at time t with paging parameter p. Some implications of the GIP are: (1) Paging algorithms which satisfy the GIP also satisfy the IP, but not vice-versa. (2) [ B(t, Pl)[ -< [ B(t, P2)[- This ensures that there is no parameter-virtual memory anomaly. (3) A(t, Pl) --- h(t, P2) where A = 0 if there is no fault at time t, and A = 1 if there is a fault at time t. Since the number of faults is given by ~t A(t, p) this relation guarantees that there is no parameter-fault rate anomaly. (4) (2) and (3) above imply that virtual memoryfault rate anomalies are not possible. (5) GIP cannot guarantee the absence of real memory-fault rate and parameter-real memory anomalies. Note that WS follows the GIP and thus does not exhibit the virtual memory-fault rate, parameter-virtual memory, and parameter-fault rate anomalies. It does, however, exhibit the real memory anomalies. PFF, on the other hand, does not obey the GIP, as shown by Figure 1 (t = 18) and Figure 2 (t = 16), and indeed it exhibits all the anomalies mentioned earlier. For fixed partition paging algorithms, the memory size can be regarded as the algorithm parameter. Mean virtual memory and real memory allocations are identical. From these two observations, the five anomalies defined above reduce to a single anomaly relating memory allocation and fault rate. This is the anomaly Belady et al. observed for the FIFO algorithm. 6. Comments and Conclusions Several observations can be made about these anomalies. First, it is costly to derive the performance of paging algorithms that violate the GIP [10, 12]. In contrast, the performance of paging algorithms satisfying GIP can be computed simply [9, 13]. Second, anomalous behavior makes systems more difficult to control. System designers are often interested in optimizing performance by controlling the load [9]. Load control is attempted by varying the paging algorithm parameter. A load control based on an anomalous performance measure may be unstable because a change of given sign in the parameter need not produce changes of corresponding sign in the controlled variable. That is, anomalous algorithms may have nonmonotonic performance properties. There is little experience telling how serious this difficulty is in a practical multiprogramming system. 236 Third, there is the operational question, whether to use real or virtual time measures as control functions. Paging algorithms satisfying the GIP, such as WS, are free of parameter-virtual memory, virtual memory-fault rate, and parameter-fault rate anomalies; thus stable load control using virtual time measures is possible. Controls based on real time measures, however, may not be stable owing to possible real memory anomalies. We have presented here a structure, together with definitions and examples illustrating anomalies in the behavior of common paging algorithms. Analysts and designers need to understand this behavior to achieve better control mechanisms. Acknowledgment. The authors are thankful to P. J. Denning for his valuable suggestions. Received April 1976; revised February 1977 References 1. Belady, L.A., Nelson, R.A., and Shedler, G.S. An anomaly in space time characteristics of certain programs running in a paging machine. Comm. ACM 12, 6 (June 1969), Belady, L.A. A study of replacement algorithms for a virtual computer. IBM Syst. J. 5, 2 (1966), Chu, W.W., and Opderbeck, H. The page fault frequency replacement algorithm. AFIPS 1972 FJCC, Vol. 41, AFIPS Press, Montvale, N.J., pp Coffman, E.G., and Ryan, T.A. A study of storage partitioning using a mathematical model of locality. Comm. ACM 15, 3 (March 1972), Denning, P.J. Virtual memory. Computing Surveys 2, 3 (Sept. 1970), Denning, P.J., and Graham, G.S. Multiprogrammed memory management. Proc. IEEE 63, 6 (June 1975), Denning, P.J. The working set model for program behavior. Comm. ACM 11, 5 (May 1968), Denning, P.J., and Schwartz, S.C. Properties of the working set model. Comm. ACM 15, 3 (March 1972), Denning, P.J., and Slutz, D.R. Generalized working set and optimal measures for segment reference strings. Tech. Rep. CSD-TR-178, Comptr. Sci. Dept., Purdue U., Lafayette, Ind., March Graham, G.S. A study of program and memory policy behavior, Ph.D. Th., Comptr. Sci. Dept., Purdue U., Lafayette, Ind., Dec Gupta, R.K. Program reference behaviour and dynamic memory management. D.Sc. Diss., Dept. EE, Washington U., St. Louis, Mo., Dec Mattson, R.L., Gecsei, J., Slutz, D.R., and Traiger, I.L., Evaluation techniques for storage hierarchies. IBM Syst. J. 9, 2 (1970), Slutz, D.R., and Traiger, I.L. A note on the calculation of average working set size. Comm. ACM 17, 10 (Oct. 1974)