Page Faults Minimization for Virtual Memory Systems Using Working Set Strategy

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 running out of 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 [2,3]. However, this can lead to page faults. It happens when a process tries to access a virtual memory address for which there's 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 [4,5,6]. 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 [7,8]. Program code transformations, such as program restructuring [9,10,11] and refactoring [12,13,14,15,16], 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 [17,18]. 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 [19,20]. The Working Set strategy, proposed by P.Denning [21], aims to prevent thrashing (excessive swapping that slows down the system) by ensuring that the pages a 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 [22] 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 [23] 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. Also, in [24,25,26] discussed working set size (WSS) estimation to predict memory demand in virtual machines, which helps optimize memory management. By accurately estimating WSS, the strategy minimizes page faults by ensuring sufficient memory allocation to meet actual usage needs. The working set strategy solves the problem of page faults by preventing actively used pages from being freed, even if the code is suboptimal. However, poor locality increases the size of the working set and makes it too large to fit in RAM, which can negate the benefits of the strategy. We propose an approach to optimize the working set size by using combinatorial space, in the form of Hasse diagram. 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 has also a fundamental aspect [27,28,29,30,31] 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 identifing functional and corresponding constraints using the working set swapping strategy to minimize page faults. We use the geometric interpretation of the computational process because it offers a visual and analytical tool for solving a problem that is typically approached through algorithmic or heuristic methods. This approach could potentially reveal patterns or properties not evident in purely computational models.

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 as “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 a system itself. Let $v_r,$ be a length of r-th page, $r=\mathrm{1,2},\dots ,p$ and $l_i$ be a length of block$i$,$i=\mathrm{1,2},\dots ,n.$ Thus the system supports multidimensional size of pages [32]. As blocks we mean a part of the code such as subroutines, linear segments of a code, separate interacting programs, data blocks and 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}$, 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 of such kind 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 corresponding denotation for control state, we will use $q$. The control state $q_t$ of the program at moment $t$, it is a sequence of program references to their pages for the last $k$ moments before moment $t$. Figure 1 indicated that control state $q$ is $q=\left(i_1,i_2,\dots ,i_{m\left(q\right)}\right)$ where $i_j$ is block number $(j=\mathrm{1,2},\dots ,m\left(q\right))$, which belongs to $q$ and any of them marked as 〇. Another one symbol $⨂$ in Figure 1 means blocks (or its numbers) which does not belong to $q$ but belong to corresponding page of working set $R\left(q,x\right)$ and present in the physical memory. In other words, all elements 〇 are blocks that are often referenced and they form the working set, other elements $⨂$ 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) [33], which are described below:

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

Constraint (a): Total length of the blocks belong to any page does not exceed the length of this page.

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

Constraint (c): Total length of any working set generated while execution of the program code does not exceed some system constant that 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 of 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=(i_1,i_2,\dots ,i_{m\left(q_t\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 [34]. 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$ [35]. 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 restore as a warm start (restart) and treat it as one additional page fault, which we will take into account in additional expressions (1), (2) for functionals of main and auxiliary problems.

Let the set of control state $q$ be denoted as $Q$. When the set $Q$ is formed we have to find the subset of the $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 2, 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 poles 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=\mathrm{\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.$ And, node $\left(\mathrm{2,3}\right)$ of the level 2, connects with two nodes at level 1, namely, $\left(2\right)$ and $\left(3\right)$ and connects also with four nodes at level 3, namely, $(\mathrm{1,2},3)$, $(\mathrm{2,3},4)$, $(\mathrm{2,3},5)$ $(\mathrm{2,3},6).$ Among nodes of the singled out path, black nodes are: (2,3), (1,2.4), (1,3,4,5), (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) (3).

Figure 3 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 are existing 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$ already is 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.

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}$. As well, it is useful to determine the connection between the calculation that will be done 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 j-th run of the program $j=\mathrm{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=\mathrm{1,2},\dots ,h$$

and a mean value:

$$E_{qi}^{\left(h\right)}=\left(1/h\right){\sum }_{j=1}^h{\xi }_{qi}^{\left(j\right)},\hspace{1em}\mathrm{f}\mathrm{o}\mathrm{r} \mathrm{a}\mathrm{n}\mathrm{y} q\in Q,i=\mathrm{1,2},\dots ,n.$$

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

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

In other words, the value ${\delta }_{qi}\left(x\right)=0$ is corresponding 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$ is corresponding 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 =\sum _{q\in Q.}{\sum }_{i=1}^n{\xi }_{qi}·{\delta }_{qi}\left(x\right)+{\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)=\sum _{q\in Q.}{\sum }_{i=1}^n{E}_{qi}·{\delta }_{qi}\left(x\right)+{\sum }_{i=1}^n{E}_{q_{0}i}⟶\underset{x\in \mathrm{X}}{\mathrm{m}\mathrm{i}\mathrm{n}}$$

(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 holds:

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

(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 auxiliary problem (2) registers in the form:

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

(3)

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

(4)

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

(5)

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

(6)

where in (5) the value $v_r$ is length of page $r,r=\mathrm{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(q,x)$

Constraint (5) contains |Q| inequalities and probably there are 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:

$$\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(q,x)\right|$ be the length of the working set $R(q,x)$ $q\in Q$, and $x\in X.$ To give a ground for substitution it is worth paying attention to Figure 2 and Figure 3 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: if $q\subseteq \widehat{q}$ then $R(q,x)\subseteq R(\widehat{q},x)$ and $\left|R(q,x)\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 3, 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).

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), (4) and 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), (7) show instead of controlling a size of any $R\left(q,x\right)$ with totally $\left|Q\right|$ inequalities, 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 second sum in (1) or (2) has instead of $i=\mathrm{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):

$$\sum _{\widehat{q}\in \widehat{Q}}\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 \sum _{q\in Q.}{\sum }_{i=1}^n{E}_{qi}^{\left(h\right)}·{\delta }_{qi}\left(x\right)$$

(8)

From [19,36] it follows that, if it is possible to solve the problem with valuation function, which has been written also in (9)

$$\sum _{\widehat{q}\in \widehat{Q}}\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)⟶\underset{x\in \mathrm{X}}{\mathrm{m}\mathrm{i}\mathrm{n}}$$

(9)

then it gives the opportunity, with appropriate complexity, to get an exact (optimal) solution of the problem (2) with 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 3, 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 of 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 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^{\ast }$ , will be an $\epsilon$ - optimal solution of the problem (1) in sense:

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

(10)

where the matrix $x^{\ast }$ 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=\mathrm{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=\mathrm{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 (see (8)) 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),$$

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=\mathrm{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^{\ast }$ can be taken as the solution of (1) in the sense of the inequality (10).

We used a heatmap technique to visualize page faults and different working set sizes as shown in Figure 4(a), (b) and (c), where are shown the number of page faults with a different working set size and a fixed Physical Memory Size. Figure 4(d) indicates a comparison result of page faults simulation in different algorithms like Working Set, LRU (Least Recently Used) and FIFO (First In, First Out). 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 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, a 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 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 conducted two more experimental studies using a 10-node FPGA-based system arranged in a ring topology. These experiments extend the original analysis by comparing caching algorithms and exploring the impact of varying cache sizes, using a random memory access workload to simulate a worst-case scenario. 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 shows the results indicate 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 seconds. LRU and FIFO showed similar performance, with average fault times of 7 µs and frequencies around 38%, resulting in execution times of 14.5 seconds. Random Replacement performed the worst, with a fault time of 8 µs, a frequency of 40%, and an execution time of 15 seconds.

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 seconds to 12.8 seconds as shown in Figure 5a. Beyond 10%, at 20%, the frequency stabilized at 32%, and execution time plateaued at 12.7 seconds, 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 seconds to 13.5 seconds. However, at 20%, execution time rose to 14 seconds despite a frequency of 29%, as reduced data memory led to more frequent evictions and reloads as shown Figure 5b.

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

4. Discussion

The results of the simulation experiments show that the locality of accesses to memory pages is a key factor for increasing the efficiency of paging algorithms. We see that Working Set and LRU are the most efficient paging algorithms, while FIFO is inferior to them in all parameters. Cache size optimization reveals a sweet spot around 10% for both free and data memory caching. Beyond this, free memory caching yields minimal gains, while overflow caching introduces trade-offs due to limited data space. This suggests a need for careful memory allocation to balance caching benefits and data availability. Future research could investigate dynamic cache sizing algorithms that adapt to workload changes or explore realistic application-specific workloads to broaden the applicability of these findings.

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.

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.