Mathematical Analysis of Page Fault Minimization for Virtual Memory Systems Using Working Set Strategy

Abstract

Poor code locality in virtual memory systems significantly contributes to page faults, leading to degraded system performance. Although many solutions aim to minimize page faults, most rely on clustering techniques that do not quantify the approximation error relative to the optimal solution. In this work, we develop a novel mathematical model based on the Working Set strategy combined with a geometric interpretation of the computational process via a Hasse diagram. This approach enables the reduction of the problem dimensionality and facilitates identification of critical control states under realistic constraints. We formalize the minimization of expected page faults as a discrete optimization problem with well-defined functionals and constraints. Experimental evaluation demonstrates that our model achieves lower average page faults and execution times compared to classical algorithms, especially under poor code locality conditions. Our method also provides a foundation for obtaining ε-optimal solutions and paves the way for designing efficient and cost-effective page replacement algorithms with provable guarantees. These contributions establish both theoretical and practical advances in virtual memory management.

1. Introduction

Virtual memory is a technique in memory management that allows a computer to use more memory than is physically available by temporarily transferring data from Random Access Memory (RAM) to disk storage. This is essential for running large programs or multiple applications simultaneously without exhausting physical memory [1]. Virtual memory allows processes to use more memory than is physically available by swapping data between physical memory and secondary storage. This is a key mechanism in systems with virtual memory, where memory is divided into pages and the operating system dynamically manages their placement between RAM and disk. However, this can lead to page faults. It happens when a process tries to access a virtual memory address for which there is currently no valid mapping in physical RAM, and this is called “minor fault”. Page faults can also be the result of poor code locality. Poor code locality directly affects the frequency of page faults because it determines how often and in what order the program accesses memory pages [2,3,4]. Poor code locality causes the program to switch between pages frequently and can lead to thrashing (the system spends more time paging than executing code). The problem is how to relocate blocks (or program segments) across pages of virtual memory to minimize page faults [5,6]. Program code transformations, such as program restructuring [7,8,9] and refactoring [10,11,12,13,14], as well as various forms of code reorganization, have a positive impact on page faults, particularly in terms of locality. The absence of a definitive solution to this problem has sustained ongoing interest and research in both past and present studies.

Many formulations of page faults or program optimization problems lead to complex combinatorial challenges, making it necessary in practice to rely on approximate or heuristic approaches. Most existing research in this area is based on clustering techniques [15,16]. While these techniques have shown improvements in experimental settings, they provide only approximate solutions with unknown accuracy, i.e., the cluster approach does not estimate how the solutions are obtained far or close to unknown exact (optimal) solutions [17,18]. The Working Set (WS) strategy, proposed by P. Denning [19], aims to prevent thrashing (excessive swapping that slows down the system) by ensuring that the pages and process needs are resident in memory. This strategy is particularly relevant for optimizing performance in systems with limited RAM, as it balances the degree of multiprogramming (running multiple processes) and CPU utilization. In addition to the experimental comparison with classical algorithms such as the Working Set, Least Recently Used (LRU), and First In First Out (FIFO), this study also examines recent research efforts aimed at optimizing virtual memory management and reducing page fault rates. In [20], the proposed page replacement policy monitors the current working set size and controls the deferring level of dirty pages, preventing excessive preservation that could lead to increased page faults, thus optimizing performance while minimizing write traffic to PCM. In [21], authors modified the ballooning mechanism to enable memory allocation at huge page granularity. Next, they developed and implemented a huge page working set estimation mechanism capable of precisely assessing a virtual machine’s memory requirements in huge page-based environments. Integrating these two mechanisms, they employed a dynamic programming algorithm to attain dynamic memory balancing. Furthermore, other studies [22,23,24] have focused on workload-aware estimation of working set sizes in virtualized systems, presenting adaptive memory allocation strategies that mitigate page faults by accounting for workload-specific patterns. Such techniques can complement our proposed model, which relies on a formal discrete approach combined with averaging across multiple program executions, thereby extending its applicability to complex and dynamic execution environments. However, unlike existing approaches, our method introduces a geometric interpretation of the computational process through Hasse diagrams, which not only reduces the dimensionality of the optimization problem but also provides an algorithmic foundation for systematically identifying critical memory states. This problem is classified as NP-hard, meaning that finding the optimal solution is computationally hard for large instances, as it would require checking an exponentially large number of possibilities. Thus, the research also has a fundamental aspect [25,26,27,28] that has encouraged us in our research efforts.

In this paper, we focus on the problem of page faults minimization for virtual memory systems. Motivated by the need to achieve either an optimal or near-optimal solution, our goal is to construct an approach based on identifying functional and corresponding constraints using the working set swapping strategy to minimize page faults. The novelty of this work lies in introducing a mathematical approach that integrates the Working Set strategy with a geometric interpretation of the computational process through Hasse diagrams. A key innovative element is the use of the Hasse diagram. The diagram is not merely a visualization tool but becomes an algorithmic foundation for reducing the dimensionality of the problem of page faults minimization. This approach enables a systematic identification of critical memory states and formalizes the optimization of program code block allocation across memory pages under strict functional and combinatorial constraints, paving the way for deriving optimal or ε-optimal solutions. Furthermore, the study establishes a foundation for the development of adaptive and intelligent page replacement algorithms that go beyond traditional heuristic-based approaches. Experimental results demonstrate the superiority of the proposed method over classical page replacement algorithms, emphasizing its significance for advancing next-generation memory management mechanisms.

2. Methods

In computing systems with page-based organization of the virtual memory, programs generate a sequence of references (accesses) to their pages during execution, which we will call “control state”. At any moment of program execution, the physical memory (RAM) does not contain all pages of the program, but only a part of them (the resident set). Figure 1 shows an example of virtual and physical memory. Virtual memory contains blocks of different sizes divided into pages. The physical memory contains copies of the virtual memory pages, and here the blocks are restructured. The size of the physical memory at any moment of the computational process is much smaller than the size of the virtual memory. Let the program code with poor locality that requires segmentation consist of $n$ blocks with numbers $i_1,i_2,\dots ,i_n$ which are singled out in advance and scattered over $p$ pages $S_1,S_2,\dots ,S_p$ of a virtual memory.

The code execution causes a problem because of generating a redundant number of page faults, which can be greatly affected by the reason of poorly structured program code and that reduces performances both of the program code and the system itself. Let $v_r,$ be a length of r-th page, $r=1,2,\dots ,p$ and $l_i$ be a length of block $i$, $i=1,2,\dots ,n.$ Thus, the system supports the multidimensional size of pages. As blocks, we mean a part of the code such as subroutines, linear segments of a code, separate interacting programs, data blocks, etc.. Distribution of blocks $i_1,i_2,\dots ,i_n$ over pages $S_1,S_2,\dots ,S_p$ is assigned, for example, via Boolean matrix $x={\left(x_{ri}\right)}_{p\times n}$ as shown in Figure 2, where an element $x_{ri}=1$, if the block with number $i$ belongs to the page with number $r$ and $x_{ri}=0$, otherwise. All such kind of matrices we denote via $X$.

In our case, working set $R\left(q,x\right)$ is generated by control state $q$ and matrix $x.$ As the corresponding denotation for the control state, we will use $q$. The control state $q_t$ of the program at moment $t$, is a sequence of program references to their pages for the last $k$ moments before moment $t$. Figure 1 indicates that control state $q$ is $q=\left(i_1,i_2,\dots ,i_{m\left(q\right)}\right)$ where $i_j$ is block number $\left(j=1,2,\dots ,m\left(q\right)\right)$, which belongs to $q$ and any of them marked as 〇. Another one symbol $\mathrm{\otimes }$ in Figure 1 means blocks (or its numbers) which does not belong to $q$ but belongs to the corresponding page of working set $R\left(q,x\right)$ and is present in the physical memory. In other words, all elements 〇 are blocks that are often referenced and they form the working set; other elements $\mathrm{\otimes }$ are also blocks that do not form the working set, but they can be present in physical memory at any moment of the computational process. For the matrix $x\in X$, there are constraints (a)–(c) [29], which are described below:

Functional: As a functional of the main problem, we will take a mathematical expectation of the number of page faults for one run of the program code. As a functional of the auxiliary problem, we will take the mean value of page faults for $h\ge 1$ runs of the program code.

Constraint (a): The total length of the blocks belonging to any page does not exceed the length of this page.

Constraint (b): Any block of the program code belongs to only one page of the program code.

Constraint (c): Total length of any working set generated while the execution of the program code does not exceed some system constant that is known in advance.

Constraints (a)–(c) have to be assigned by a matrix $x={\left(x_{ri}\right)}_{p\times n},$ which defines distribution of the blocks $i_1,i_2,\dots ,i_n$ over pages $S_1,S_2,\dots ,S_p.$ An important role for our consideration plays a Boolean matrix $x={\left(x_{ri}\right)}_{p\times n}$ which determines the structure of a program, i.e., distribution blocks $b_1,b_2,\dots ,b_n$ of a program over pages $S_1,S_2,\dots ,S_p.$ For $x,$ it has to hold constraints (a)–(c), and all such kind of matrices form the set $X$. Next, we present an example of the structure of matrix $x={\left(x_{ri}\right)}_{p\times n}$ with control state $q=\left(i_1,i_2,\dots ,i_{m\left(q_t\right)}\right)$ singled out among columns of matrix $x={\left(x_{ri}\right)}_{p\times n}$. The matrix $x={\left(x_{ri}\right)}_{p\times n}$ helps to calculate the function ${\delta }_{qi}\left(x\right)$.

2.1. Geometric Interpretation of the Computational Process

We consider the geometric interpretation of the computational process using the Hasse diagram, a graphical representation of a partially ordered set [30]. Each element of the set is represented by a node. A line (edge) exists between each pair of nodes $b$ and $c$ such that $b\le c$ and there is no d such that $b\le d\le c$, i.e., we say that $c$ covers $b$. In combinatorial space, the control state $q_0$ may happen at latter moments when our program unexpectedly offloads from the physical memory and after a while the program activates as if it runs from the start (cold start). Another way to start is a warm start when the system is trying to continue the computing process from level 1 or 2. Further, we propose that any such event should be restored as a warm start (restart) and we can treat it as one additional page fault, which we will take into account in additional expressions (1) and (2) for functionals of main and auxiliary problems.

Let the set of control states $q$ be denoted as $Q$. When the set $Q$ is formed, we have to find the subset of $Q$, which we denote as $\widehat{Q},$ and which will be useful for us under the constraint (c). Any element $\widehat{q}\in \widehat{Q}$ has the property; namely, in the $Q,$ there is no element $q$ such as $\widehat{q}⊊q$. Conceptually, looking at the Hasse diagram, as shown in Figure 3, the element $\widehat{q}$ is a node which is a peak-node under any random walk path over nodes of the Hasse diagram. Following our approach, for any sequence of control state already from $Q$ along the axis $t$ with fixed $\theta \in D$ is a corresponding random walk path over nodes of the combinatorial space. Thus, the computational process is a random walk path through the nodes of the combinatorial space, for which we use the Hasse diagram.

A Hasse diagram is a two-pole combinatorial space with a number of blocks $n=6$, $n+1,$ and several levels. The down pole, located at the zero level $\left(0\right),$ corresponds to the empty set $q_0=\varnothing$ for starting any process. The upper pole corresponds to a number of blocks of the program code, i.e., $n=6$. Elements of the set $Q$ correspond to appropriate nodes of the combinatorial space. Any control state $q=(i_1,i_2,\dots ,i_m)\in Q$ that corresponds to the intermediate node $(i_1,i_2,\dots ,i_m)$. For example, at level $l(1\le l<n)$, is an ordered record, such that $i_1<i_2<\dots <i_m$ and connects with $m$ nodes of the level $l-1$ and with $n-m$ nodes of the level $l+1$. Also, node (2,3) of the level 2, connects with two nodes at level 1, namely, (2) and (3), and connects also with four nodes at level 3, namely, (1,2,3), (2,3,4), (2,3,5), and (2,3,6) Among nodes of the singled-out path, black nodes are (2,3), (1,2,4), (1,3,4,5), and (3,6) and are needed for us to optimize nodes $\overline{q}$, which are down nodes of the edges ( $\overline{q,}\widehat{q}),$ namely, (2,4), (1,4,5), and (3).

Figure 4 indicates a dedicated random walk path along nodes under $k=4$, that correspond to a working set and singled-out path with $\widehat{q}$ and $\overline{q}$ nodes on it. Eventually, we have a random walk path over nodes with $\widehat{q}$ and $\overline{q}$. Under multiple runs nodes, $\widehat{q}$ and $\overline{q}$ can be changed, but, at all times, they exist in the computional process, including the final situation, when the set $Q$ is determined. The only point to note for description of an algorithm to determine $\widehat{Q}$ is very simple and consists of sequentially sorting out elements of the $Q$ and comparison to a current $q.$ First, it takes removal of the current element $q$ from $Q.$ If yes, i.e., then $q$ has to be crossed out of consideration as the candidate for $\widehat{q}$. If no, then we have to continue the check of an inclusion into the next $q$ from $Q.$ If we cannot find such $q$ from $Q$ and the set $Q$ is already exhausted then $q$ becomes $\widehat{q}$ and we add $\widehat{q}$ into $\widehat{Q}$. We repeat the process with the next elements of $Q$ as $q$ until the set $Q$ is exhausted and we form the set $\widehat{Q}.$ It has to be noted that any run of the program takes finite time. The construction of the set $\widehat{Q}$is carried out by sequentially verifying the elements of the set $Q$ for maximality with respect to inclusion. The theoretical computational complexity of this process is $O\left({\left|Q\right|}^2\right)$, since each element must be compared with all others. In practice, due to constraints on the size of the working set and the application of optimizations, the construction of $\widehat{Q}$ remains computationally feasible for real-world tasks.

Importantly, the Hasse diagram in our approach is not merely a visualization tool but an integral part of the algorithmic optimization. By representing the combinatorial structure of all control states as a partially ordered set, the diagram enables us to efficiently identify the subset of control states that are admissible working sets under constraint (c). In practice, these are the peak-nodes that are the largest memory-resident sets encountered along any execution path. Enforcing the memory constraint (c) only on these peak states is sufficient, since if every maximal working set satisfies the size limit, all intermediate subsets will automatically satisfy it as well. This insight, derived from the Hasse diagram’s poset structure, dramatically reduces the dimensionality of the constraint system: the full inequality system (5) collapses to a much smaller system (7) that considers only critical states. In other words, the partial order embodied in the Hasse diagram guides a systematic simplification of the constraints by revealing which working set inequalities are essential and which are redundant, thus directly contributing to the optimization process and not just to visualization. Furthermore, the Hasse diagram provides a framework for interpreting and tracking the random walk paths of program execution through the state space. Each node-to-node transition in the diagram corresponds to adding or removing a block in the working set, and we assign a weight to each such edge indicating whether this transition incurs a page fault. This edge-weighting scheme allows us to map the occurrence of page faults directly onto the poset structure: a sequence of memory references (a control state trajectory) becomes a path on the Hasse diagram whose cumulative edge weight equals the total number of page faults for that execution. By exploiting this weighted poset, we construct valuation functions that aggregate page fault costs along any path, which in turn guides our optimization. In effect, the Hasse diagram acts as a computational scaffold for the algorithm—it organizes the state space so that page fault events can be counted and optimized via edge weights, facilitating the application of discrete optimization to find near-optimal solutions. Thus, the Hasse diagram supports every step of our approach: it encodes the state space structure, restricts the search to feasible and critical states, reduces the number of constraints, and provides a basis for calculating and minimizing page faults via the weighted edges and valuation function.

2.2. Functionals $F^0\left(x\right)$ and $F^{\left(h\right)}\left(x\right).$ Constraints for $x\in X$

In this subsection, we describe functionals and constrains of the main and auxiliary problems. We will start by finding expressions of the functional of both the main and auxiliary problem and expressions for corresponding constrains for matrix $x={\left(x_{ri}\right)}_{p\times n}$. Also, it is useful to determine the connection between the calculation that will be conducted and its geometric interpretation. Using information given above, we introduce a random variable ${\xi }_{qi}$ which is a number of references to block $i$ under the execution of control state $q$ for one run of the program. Let random variable ${\xi }_{qi}^j$ be the same as ${\xi }_{qi}$ but in the j-th run of the program $j=1,2,\dots ,h.$ Let expected value of ${\xi }_{qi}$ and ${\xi }_{qi}^j$ be

$$E({\xi }_{qi})=E({\xi }_{qi}^j)=E_{qi},j=1,2,\dots ,h.$$

and a mean value:

$$E_{qi}^{\left(h\right)}=\left(1/h\right){{\displaystyle \sum }}_{j=1}^h{\xi }_{qi}^{\left(j\right)}, \mathrm{for} \mathrm{any} q\in Q, i=1,2,\dots ,n.$$

Calculation of the ${\delta }_{qi}\left(x\right)$ can be conducted in the following way:

$${\delta }_{qi}\left(x\right)=\left\{\begin{array}{c}0, \mathrm{if} \mathrm{block} i\in S\in R\left(q,x\right)\hfill \\ \\ 1, \mathrm{otherwise} \hfill \end{array}\right.$$

In other words, the value ${\delta }_{qi}\left(x\right)=0$ corresponds to the absence of the page fault under event $q\to i$, the value ${\delta }_{qi}\left(x\right)=0,$ if block $i$ belongs to some page $S$ from $R\left(q,x\right).$ Otherwise, the value ${\delta }_{qi}\left(x\right)=1$ corresponds to the page fault. If block $i\in q$, then it has to be ${\delta }_{qi}\left(x\right)\equiv 0$ for any $x\in X.$ Next, we can remove the control state $q_0$ from $Q$, then a total number of page faults for one run of the program will be

$$\xi ={\displaystyle \sum }_{q\in Q.}{{\displaystyle \sum }}_{i=1}^n{\xi }_{qi}·{\delta }_{qi}\left(x\right)+{{\displaystyle \sum }}_{i=1}^n{\xi }_{q_{0}i}$$

and for the functional of the main problem which has to be minimized, we have

$$F^0\left(x\right)={\displaystyle \sum }_{q\in Q.}{{\displaystyle \sum }}_{i=1}^n{E}_{qi}·{\delta }_{qi}\left(x\right)+{{\displaystyle \sum }}_{i=1}^n{E}_{q_{0}i}\to \underset{x\in \mathrm{X}}{\min }$$

(1)

It is worth noting that in the expression for $\xi$ the any value ${\xi }_{qi}$ does not depend on matrix $x\in \mathrm{X}$ and, quite the opposite, the function ${\delta }_{qi}\left(x\right)$ depends on given $q\in Q$ and $i$ and $x\in \mathrm{X}$ and does not depend on random event $q\to i$ and where it happens. For the functional $F^{\left(h\right)}\left(x\right)$ of the auxiliary problem, it holds that

$$F^{\left(h\right)}\left(x\right)={\displaystyle \sum }_{q\in Q.}{{\displaystyle \sum }}_{i=1}^n{E}_{qi}^{\left(h\right)}{\delta }_{qi}\left(x\right)+{{\displaystyle \sum }}_{i=1}^n{E}_{q_{0}i}^{\left(h\right)}\to \underset{x\in \mathrm{X}}{\min }$$

(2)

It is interesting to note that value $E_{qi}^{\left(h\right)}$ from (2) can be assigned to the edge that connects the node $q$ and the node $q\cup i$ in the Hasse diagram, where the function ${\delta }_{qi}\left(x\right)=1$ and otherwise. This edge has to be weighted as zero if the function ${\delta }_{qi}\left(x\right)=0$. It may help to calculate the value of the functional $F^{\left(h\right)}\left(x\right)$ for fixed $x\in \mathrm{X}.$ It will be sufficient to determine whether the weight of any edge in question is 1 or 0, which means whether a page error has occurred or not. The system of constraints (a)–(c) setting the set of $X$ of admissible solutions for both the main problem (1) and for the auxiliary problem (2) registers in the form:

$${\displaystyle \sum }_{i=1}^n{l}_i\cdot x_{ri}\le v_r ,r=1,2,\dots ,p;$$

(3)

$${\displaystyle \sum }_{r=1}^p{x}_{ri}=1, i=1,2,\dots ,n;$$

(4)

$${\displaystyle \sum }_{r=1}^p{v}_r\cdot H_{qr}\left(x\right)\le N_q ,q\in Q;$$

(5)

$$x_{ri}\in \left\{0,1\right\}, r=1,2,\dots ,p;i=1,2,\dots ,n.$$

(6)

where in (5), the value $v_r$ is the length of page $r, r=1,2,\dots ,p$. The system (3)–(6) contains $p+n+\left|Q\right|$ non-trivial correlations. Note that constraints (3)–(5) correspond to constraints (a)–(c), respectively. The function $H_{qr}\left(x\right): H_{qr}\left(x\right)=1$, if page $S_r\in R\left(q,x\right)$ and $H_{qr}\left(x\right)=0$, otherwise, i.e., the function $H_{qr}\left(x\right)$ is the characteristic function of the $R\left(q,x\right)$. Under given $q$ and $r,$ it is easy to calculate $H_{qr}\left(x\right)$ via elements of the matrix $x$, namely, if q = ( $i_1,i_2,\dots ,i_{m\left(q\right)})\in Q$ then $H_{qr}\left(x\right)=\underset{1\le j\le m\left(q\right)}{max}{x}_{r{i}_j}.$

2.3. Reduction in a Number of Inequalities of the Control State in Working Set $R\left(q,x\right)$

Constraint (5) contains |Q| inequalities and there are probably a lot. Here is an opportunity to reduce essentially a number of inequalities in (5). As already mentioned, from a practical point of view, we may propose that there exists a system constant, let it be $N$, which limits the dimension of any working set $R\left(q,x\right)$and which is known in advance. It is necessary to note the set $\widehat{Q}$ and then we can substitute system (5) for

$${\displaystyle \sum }_{r=1}^p{v}_r\cdot H_{\widehat{q}r}\left(x\right)\le N, \widehat{q}\in \widehat{Q}$$

(7)

but first we must put in (5) for all $N_q=N$, $q\in Q.$ Let $\left|R\left(q,x\right)\right|$ be the length of the working set $R\left(q,x\right),$  $q\in Q$, and $x\in X.$ To give a ground for substitution, it is worth paying attention to Figure 3 and Figure 4 with black nodes on them corresponding to control state $\widehat{q}\in \widehat{Q}$ and nodes $q\in Q,$ such as $q⊊\widehat{q}$. Then, the next correlations hold as follows: if $q\subseteq \widehat{q}$ then $R\left(q,x\right)\subseteq R\left(\widehat{q},x\right)$ and $\left|R\left(q,x\right)\right|\le ,$where $q\in Q$, $\widehat{q}\in \widehat{Q}$ and if inequality (7) holds for some $\widehat{q}\in \widehat{Q}$ then it also holds for any $q\in Q$ which $q\subseteq \widehat{q}$. Here, it is taken into account that any $q\in Q$ belongs to at least one $\widehat{q}$ from $\widehat{Q}$ as shown in Figure 4, node (3). Evidently, the set $X$ of admissible solutions is non-empty since an initial distribution block $i_1,i_2,\dots ,i_n$ over pages $S_{g_1},S_{g_2},\dots ,S_{g_p}$ satisfies constraints (3)–(6).

The approach proposed in this work is based on a mathematical model that incorporates dynamical size pages, as reflected in the system of constraints (3), where the length of each page $v_r$ may differ. This model is more general and flexible, allowing for the representation of both variable and fixed page sizes. In the case of systems with fixed page sizes, the model reduces to a special case with identical values $v_r=v$ for all pages $r$. All derived results, including the formalization of working sets, functionals, and constraints, remain applicable, while the computational component is simplified due to the uniformity of page sizes. Thus, the proposed method is universal and applicable to systems with both variable and fixed page sizes, which broadens its scope of practical applicability and ensures its relevance to the majority of traditional virtual memory systems.

3. Results

The nonlinear model of the reorganization of the program code which is constructed above contains nonlinear functional (1) and/or (2) and both linear inequalities (3) and (4) and a nonlinear system of constraints in (5). The power of the set $\widehat{Q}$ in (7) is not too large in contrast with the power of $Q$ in (5). The constraints (5) and (7) show instead of controlling a size of any $R\left(q,x\right)$ with totally $\left|Q\right|$ inequalities, and after substitution (7) instead of (5) we have in (7) only $\left|\widehat{Q}\right|$ inequalities. As for functional (1) or (2), it can be reduced to a number of addends in (1) or (2) on the basis of the idea that if block $i\in q$ then ${\delta }_{qi}\left(x\right)\equiv 0$ for any $x\in X$ and the second sum in (1) or (2) has instead of $i=1,2,\dots ,n$, only the indexes $i\in I\left(q\right)$, where the set $I\left(q\right)$ does not contain such $i$ belongs to $q.$ Under given $q=(i_1,i_2,\dots ,i_{m\left(q\right)})$ and $i$ and under the event $q\to i,$ if $i_1\notin (i_2,i_3,\dots ,i_{m\left(q\right)})$ and $i\in (i_2,i_3,\dots ,i_{m\left(q\right)})$ then there will be no page fault. If $i_1\in (i_2,i_3,\dots ,i_{m\left(q\right)})$ and $i\in (i_2,i_3,\dots ,i_{m\left(q\right)})$ then there will also be no page fault. It is important to note that some methods of discrete optimization, based on construction of valuation function, in our case, for the problem (2) on the basis of geometric interpretation of the computational process, it is the lower valuation function, which is written on the left side of (8):

$${\displaystyle \sum }_{\widehat{q}\in \widehat{Q}}{\displaystyle \sum }_{\overline{q}\in Q_{\widehat{q}}}{E}_{\overline{q}{i}_{\widehat{q}\setminus \overline{q}}}^{\left(h\right)}\cdot {\delta }_{\overline{q}{i}_{\widehat{q}\setminus \overline{q}}}\left(x\right)\le {\displaystyle \sum }_{q\in Q.}{{\displaystyle \sum }}_{i=1}^n{E}_{qi}^{\left(h\right)}·{\delta }_{qi}\left(x\right)$$

(8)

To solve the problem with valuation function, which has been written also in (9):

$${\displaystyle \sum }_{\widehat{q}\in \widehat{Q}}{\displaystyle \sum }_{\overline{q}\in Q_{\widehat{q}}}{E}_{\overline{q}{i}_{\widehat{q}\setminus \overline{q}}}^{\left(h\right)}\cdot {\delta }_{\overline{q}{i}_{\widehat{q}\setminus \overline{q}}}\left(x\right)\to \underset{x\in \mathrm{X}}{\min }$$

(9)

then it gives the opportunity, with appropriate complexity, to get an exact (optimal) solution of the problem (2) with a functional on the right side of (8). The set $Q_{\widehat{q}}$ on the left part of (8) is a subset of $Q$, which is defined by a separate $\widehat{q}$ and consists of a number of $\overline{q}\in Q$. If we look to Figure 4, a node $\overline{q}$ has to be connected with node $\widehat{q}$ by the edge, i.e., ( $\overline{q},\widehat{q})$ which is the oriented edge with nodes $\overline{q}$ and $\widehat{q}$. Meanwhile, it is not necessary to take into account both on the left side of (8) and (9) the edge ( $\widehat{q}, \overline{q})$, since the weight of the ( $\widehat{q}, \overline{q})$ equals 0. On the left side of (8) for any $\widehat{q}\in \widehat{Q}$, a node $\overline{q}$ is running for edge ( $\overline{q},\widehat{q})$ until the set $Q_{\widehat{q}}$ is exhausted. We include a node $\overline{q}$ into $Q_{\widehat{q}}$ if there is at least one reference, while h runs the program, from node $\overline{q}$ to the node $\widehat{q.}$ The number $i$ on the left part of (8) is defined as $\widehat{q}\setminus \overline{q},$ i.e., $i=\widehat{q}\setminus \overline{q}.$ Let it be a denotation $i_{\widehat{q}\setminus \overline{q}}$. The left part of (8) contains a lesser number of addends than the right side of (8). The same we may say about the functional of the problem (1), i.e., about $F^0\left(x\right).$ As for the optimal solution of (1), it is interesting to point out conditions for initial data when the optimal solution of problem (2), let it be the matrix $x_h^{*}$, will be an $\epsilon$-optimal solution of the problem (1) in sense:

$$Pr\left\{\left|F^0\left(x^{*}\right)-{\mathrm{F}}^0\left(x_h^{*}\right)\right|\le \epsilon \right\}\ge 1-\eta , \epsilon >0, \eta \in \left(0,1\right)$$

(10)

where the matrix $x^{*}$ is an unknown optimal solution of the problem (1). Those conditions, first of all, imply to determine common properties of the distribution laws for the variables ${\xi }_{qi},i=1,2,\dots ,n;q\in Q$ and lower bound for the number h of executions (runs) of the code, under which inequality (10) holds.

Under the known values $E_{qi}$ in (1), i.e., the distribution law of each random variable ${\xi }_{qi},i=1,2,\dots ,n; q\in Q$ is known, the algorithm of the solution, both the initial problem (1), and the problem (2) can be based on valuation function and the property of the function ${\delta }_{qi}\left(x\right)$:

$${\delta }_{{\overline{q}}^{\prime }i}\left(x\right)+{\delta }_{{\overline{q}}^{″}i}\left(x\right)\le {\delta }_{{\overline{q}}^{\prime }\cap {\overline{q}}^{″}i}\left(x\right)+{\delta }_{{\overline{q}}^{\prime }\cup {\overline{q}}^{″}i}\left(x\right)$$

(11)

which takes place for any ${\overline{q}}^{\prime },{\overline{q}}^{″}\in \widehat{Q}\subset Q$ and represents a special case of the property of supermodularity. In the case of unknown values $E_{qi}$ (the distribution law of the random variables ${\xi }_{qi},i=1,2,\dots ,n;q\in Q$ is unknown) the situation for solution of problem (1) becomes more complicated. In this case, the problem (2) could be used as an auxiliary problem for (1) and optimal solution of (2), i.e., $x_h^{*}$ can be taken as the solution of (1) in the sense of the inequality (10).

To evaluate the effectiveness of the proposed approach, simulation experiments were conducted comparing the classical page replacement algorithms: WS, LRU, and FIFO. The primary comparison metrics included page fault handling time, page fault frequency, and total program execution time. The obtained results highlight the advantages of the WS algorithm under various memory configurations and workload conditions, while also demonstrating the behavior of the other algorithms in typical virtual memory scenarios. We used a heatmap technique to visualize page faults and different working set sizes as shown in Figure 5a–c, where the number of page faults with a different working set size and a fixed physical memory size are shown. Figure 5d indicates a comparison result of page faults simulation in different algorithms WS, LRU, and FIFO. Experiments were performed with different parameters: virtual memory size, physical memory size, working set size, access sequence length, locality factor. The Working Set algorithm tries to keep only actively used pages in memory. If the working set size is smaller than the physical memory size, the number of page faults will be low; if working set size increases, then page faults also increase accordingly. The LRU algorithm unloads the page that has not been used for the longest time. It performs well, especially when there is locality in the order of accesses.

The FIFO algorithm unloads the page that was loaded first. It shows worse results compared to LRU and the working set, especially in the presence of cyclic access patterns. The simulation results on page fault optimization show that in the fixed size of physical memory, there are fewer page faults for all algorithms. This is because more pages can be loaded simultaneously, reducing the need for paging. When the physical memory size is small, the number of faults increases because the algorithms are forced to offload pages more frequently. The heatmap shows that for a given algorithm and physical memory size, if the cell color is light, it indicates a large number of page faults. For example, an FIFO with a small physical memory size may have a high number of page faults. If the cell color is dark, it indicates a low number of page faults. For example, an LRU with a large physical memory size may have low page fault values.

Table 1. Average page faults for different algorithms.

Algorithm	Average Page Faults	Average Locality Factor
Working Set	4352	0.72
LRU	4371	0.72
FIFO	4397	0.72

presents that Working Set is the most effective when there is locality in the order of accesses, especially when the physical memory size is large. LRU performs consistently well and is a compromise between implementation complexity and efficiency. This algorithm effectively minimizes the number of page faults. FIFO is the least efficient, especially when the physical memory size is small, because it does not consider locality and may discard pages that will be used soon.

We evaluated WS, LRU, and FIFO caching algorithms with a cache size of 5% allocated from free memory. Each of the 10 nodes performed 100,000 operations, with 80% accessing local memory and 20% requesting remote data. Performance was assessed through average page fault time, page fault frequency, and total execution time.

Table 2. Performance metrics for caching algorithms.

Algorithm	Av. Page Fault Time (µs)	Page Fault Frequency (%)	Total Execution Time (s)
WS	6	35	13
LRU	7	38	14.5
FIFO	7	38	14.5

shows the results and indicates that the WS algorithm consistently outperformed the alternatives. WS reduced the average page fault time to 6 µs and the fault frequency to 35%, yielding a total execution time of 13 s. LRU and FIFO showed similar performance, with average fault times of 7 µs and frequencies around 38%, resulting in execution times of 14.5 s. Random Replacement performed the worst, with a fault time of 8 µs, a frequency of 40%, and an execution time of 15 s.

The superior performance of WS likely stems from its ability to maintain a set of actively used pages, adapting even to random access patterns. LRU and FIFO, while effective in workloads with locality, offer little advantage here, and RR’s lack of pattern consideration makes it the least efficient. We varied the cache size—1%, 5%, 10%, and 20% of total memory—using the Working Set algorithm, sourcing memory from both free reserves and data memory (overflow). The same workload and system configuration were applied. As cache size increased from 1% to 10%, page fault frequency dropped from 39% to 33%, and total execution time decreased from 14.8 s to 12.8 s as shown in Figure 6a.

Beyond 10%, at 20%, the frequency stabilized at 32%, and execution time plateaued at 12.7 s, indicating diminishing returns. Average page fault time remained steady at around 6 µs across all sizes. With data memory caching, fault frequency decreased from 38% at 1% to 30% at 10%, with execution time improving from 14.5 s to 13.5 s. However, at 20%, execution time rose to 14 s despite a frequency of 29%, as reduced data memory led to more frequent evictions and reloads as shown in Figure 6b. These experiments reaffirm the efficacy of RAM page caching, with the Working Set algorithm proving optimal for random workloads. The choice of algorithm significantly impacts performance, with WS reducing execution time by up to 14% compared to no caching (15 s).

4. Discussion

The results of the simulation experiments show that the locality of accesses to memory pages is a key factor influencing the effectiveness of paging algorithms. Among the evaluated methods, the WS and LRU algorithms exhibit the best performance in reducing page faults, whereas FIFO consistently performs worse across all parameters. Specifically, WS proves effective in retaining active pages in memory, and LRU leverages recent access history, while FIFO’s lack of locality awareness leads to frequent unnecessary evictions. Further analysis of cache size optimization reveals a performance sweet spot around 10% of total memory for both free and overflow memory caching. Increasing the cache size beyond this threshold produces diminishing returns in terms of page fault reduction. Overflow caching, in particular, introduces trade-offs due to reduced available space for data. These observations highlight the need for careful memory allocation policies that balance caching capacity with overall data availability. Although the proposed approach is grounded in a solid theoretical foundation, employing the working set model and a geometric interpretation of the computational process state, our work is not limited to purely theoretical analysis. The proposed model formulates the minimization of page faults as a discrete optimization problem with a set of functionals and constraints, thereby providing a basis for the development of a novel page replacement algorithm. In particular, by utilizing the Hasse diagram and reducing the state space to the critical nodes $\widehat{Q}$, it becomes possible to construct a computationally efficient algorithm that approximates the optimal solution with a controlled error $\epsilon$. Thus, the model serves not only as a theoretical tool but also as a foundation for the practical implementation of adaptive and intelligent virtual memory management algorithms that surpass traditional heuristics in quality. Future work will focus on the development and deployment of such an algorithm based on the proposed model, along with performance evaluation under real-world conditions.

It is worth noting that Clock and WSClock, which are practical approximations of LRU and WS, respectively, were not included in this study. However, due to their real-world relevance and lower implementation overhead, we plan to include them in future evaluations to better position our approach within a broader spectrum of paging strategies. Unlike traditional algorithms that make runtime-local decisions, our method formulates page replacement as a discrete optimization problem, minimizing the expected number of page faults across program runs. We introduce a valuation function, combined with Hasse diagram-based reduction of the search space to a core subset of control states. This allows for efficient exploration of ε-optimal configurations under real system constraints. In doing so, our work lays a theoretical and practical foundation for designing more adaptive and intelligent page replacement mechanisms beyond reactive heuristics.

5. Conclusions

Poor code locality encourages the study of program restructuring and optimization strategies, such as the Working Set strategy, to minimize page faults in virtual memory systems. This paper proposes a combinatorial approach to optimize working set size, and aims at obtaining near-optimal solutions using geometric interpretation and functional constraints. In order to optimize the calculations, a valuation function was found which includes the empirical average of the experiments and a system of constraints. Our proposed geometric interpretation of the computational process in the form of a Hasse diagram helps to reduce the dimensionality of the page faults minimization problem. The approach outlined in the paper provides a basis for finding the optimal solution to the main problem, i.e., to page faults minimization, if the minimum distribution of random variables is known in advance. Otherwise, with an unknown minimum of the random variable distribution, the constructed approach provides the basis for finding an accurate solution to the auxiliary problem, i.e., the experimental average of page faults.

The simulation experiments conducted on page replacement algorithms demonstrated the practical significance and confirmed the effectiveness of the model based on the Working Set strategy and the geometric interpretation of the computational process state. Our results show that algorithms oriented toward the active working set of pages outperform those that disregard such information in terms of both the number of page faults and execution time. This aligns with the theoretical assumptions of the model, where the minimization of page faults is achieved through the optimization of working sets, as reflected in the model’s functionals and constraints. Thus, the results section not only illustrates the overall performance patterns of classical algorithms but also provides evidence of the relevance and practical applicability of the proposed mathematical model, thereby bridging the gap between theory and practice in virtual memory management.

Currently, the Working Set strategy is usually used as a theoretical research base, either for comparison or for auxiliary purposes, as it is considered expensive to implement. However, in our case, if the program code has a block structure, then the results obtained can be used to build a fast, accessible, and affordable swap algorithm.