Défauts de page dans la version la moins récemment utilisée (LRU)

La pagination est un processus de gestion de la mémoire lié au système d'exploitation. Il stocke ou récupère certaines données de processus du stockage de données secondaire vers le stockage de données principal ou la mémoire à l'aide de segments de page. Le processus de pagination se produit lorsque le processus rencontre une erreur sur la page, où nous ne pouvons pas satisfaire le processus d'allocation avec une nouvelle page gratuite. Le processus LRU génère des exigences spécifiques en matière d'algorithme de remplacement. Lorsqu'un processus génère une nouvelle page, il détermine quelle page doit être remplacée. Prenons un exemple -

Ce que vous saisissez est utilisé dans ce processus -

N = 9, C = 4

Pages présentes pour le processus = {5, 0, 1, 3, 2, 4, 1, 0, 5}

Le résultat de sortie est : 8

Explication -

Les pages mémoire allouées sont 5, 0, 1, 3

Défauts survenus au cours de ce processus = 4

Nécessite une allocation de mémoire, la valeur est 2, remplacez LRU 5 :

Des erreurs se sont produites au cours de ce processus = 4+1 = 5

Besoin d'allouer de la mémoire avec la valeur 4, remplacez LRU 0 :

Des erreurs survenues au cours de ce processus = 5 + 1 = 6

La mémoire requise avec la valeur 1 existe déjà :

Des erreurs survenues au cours de ce processus = 6 + 0 = 6

La mémoire de valeur 0 doit être allouée pour remplacer les 3 blocs mémoire les moins récemment utilisés :

Des erreurs survenues au cours de ce processus = 6 + 1 = 7

Besoin d'allouer de la mémoire avec la valeur 5, qui remplacera LRU 2 :

Des erreurs se sont produites au cours de ce processus = 7 + 1 = 8.

L'algorithme évalue les défauts de page dans LRU

L'algorithme LRU est un procédé de remplacement évoqué dans le domaine des systèmes d'exploitation. La capacité est le nombre de pages conservées en mémoire. Nous allons maintenant définir la collection actuelle de pages dans une mémoire spécifique. Le processus place toujours les pages les moins fréquemment utilisées dans la valeur du processus.

• Étape 1 - Démarrez le processus de fonctionnement du LRU.

• Étape 2 - Déclarez un total de 0 ici.

• Étape 3 - Créez une classe vectorielle.

• Étape 4 - Construisez et déclarez un tableau avec la taille de tableau souhaitée.

• Étape 5 - Démarrez le processus avec la capacité de mémoire.

• Étape 6 - Créez une carte pour cette méthode.

• Étape 7 - Stockez la valeur de fréquence dans la carte de la page

• Étape 8 - Parcourez les éléments de la page.

• Étape 9 - Si ; l'élément requis existe dans l'emplacement de stockage de base, alors nous

Supprimez-le et poussez-le.

• Étape 10 - L'étape 9 ajoute le processus de fréquence.

• Étape 11 - Sinon, la mémoire est complètement pleine. Supprimez le premier élément et réduisez la fréquence.

• Étape 12 - Le nombre augmente.

• Étape 13 - Comparez les résultats de fréquence.

• Étape 14 - Trier par fréquence de page et résultats temporels.

• Étape 15 - Si nous obtenons la même fréquence, alors la page arrivera en premier.

• Étape 16 - Répétez le processus.

• Étape 17 - Renvoyez les résultats.

• Étape 18 - Tuez le processus.

Syntaxe pour compter les défauts de page dans LRU

int main() {
  int capacity = 4;
  int arr[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2};
 
  deque<int> q(capacity);
  int count=0;
  int page_faults=0;
  deque<int>::iterator itr;
  q.clear();
  for(int i:arr)
  {
    itr = find(q.begin(),q.end(),i);
    if(!(itr != q.end()))
    {
 
      ++page_faults;
      if(q.size() == capacity)
      {
        q.erase(q.begin());
        q.push_back(i);
      }
      else{
        q.push_back(i);
 
      }
    }
    else
    {
      q.erase(itr);
      q.push_back(i);        
    }
 
  }
  cout<<page_faults;
}
{
   int capacity = 4;
   int arr[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2};
   ArrayList<Integer> s=new ArrayList<>(capacity);
   int count=0;
   int page_faults=0;
   for(int i:arr)
   {
      if(!s.contains(i))
      {
         if(s.size()==capacity)
         {
            s.remove(0);
            s.add(capacity-1,i);
         }
		 else
            s.add(count,i);
         page_faults++;
         ++count;
       } else {
         s.remove((Object)i);
         s.add(s.size(),i);		
   }
}

Dans la syntaxe possible mentionnée ci-dessus, nous avons essayé de montrer les manières possibles d'implémenter la gestion des défauts de page LRU dans le monde des systèmes d'exploitation. Grâce à cette syntaxe intersectionnelle, nous construirons du code C++ pour interpréter et résoudre l'énoncé du problème de manière efficace.

Méthode

• Méthode 1 - Programme C++ démontrant l'algorithme LRU (Least Récemment Utilisé) avec des pages d'accompagnement pour la gestion de la mémoire dans le système d'exploitation.

• Méthode 2 - En utilisant la pagination avec l'algorithme LRU pour les fonctions d'indexation et de hachage afin de gérer la mémoire dans le système d'exploitation, le programme C++ est utilisé pour rechercher les défauts de page.

Programme C++ démontrant la gestion de la mémoire avec l'algorithme LRU (Les moins récemment utilisés) lié aux pages dans le système d'exploitation

L'algorithme LRU (Least Récemment utilisé) est une stratégie du système d'exploitation pour gérer les défauts de page. Voici le processus -

• Commencez à parcourir la page.

• Insérez des données dans une collection.

• Traitement de la page de demande.

• Continuez à se produire en même temps.

• Indice de déclaration.

• L'incrémentation des erreurs de page a commencé.

• Retrouvez la page dans la collection.

• Remplacez la page trouvée par la page actuelle.

• Ajout de problèmes.

• Mise à jour de l'index

Exemple de code 1

//C++ program to demonstrate the Least Recently Used (LRU) Algorithm attached with the paging for memory management in Operating System
#include<iostream>
using namespace std;
int main ()
{
  int nopages, nofaults, page[20], i, count = 0;
  cout << "\n\t Enter no of pages for which you want to calculate page faults:>";
  cin >> nopages;
  //it will store the numer of Pages
  cout << "\n\t Enter the Reference String:";
  for (i = 0; i < nopages; i++)

    {
      cout << "\t"; cin >> page[i];
    }
  cout << "\n\t Enter the Number of frames:"; cin >> nofaults;
  int frame[nofaults], fcount[nofaults];
  for (i = 0; i < nofaults; i++)

    {
      frame[i] = -1;
      fcount[i] = 0;
    }
  i = 0;
  while (i < nopages)

    {
      int j = 0, flag = 0;
      while (j < nofaults)

	{
	  if (page[i] == frame[j])
	    {
	      flag = 1;
	      fcount[j] = i + 1;
	    }
	  j++;
	}
      j = 0;
      cout << "\n\t***\n";
      cout << "\t" << page[i] << "-->";
      if (flag == 0)

	{
	  int min = 0, k = 0;
	  while (k < nofaults - 1) { if (fcount[min] > fcount[k + 1])
		min = k + 1;
	      k++;
	    }
	  frame[min] = page[i];
	  fcount[min] = i + 1;
	  count++;
	  while (j < nofaults)

	    {
	      cout << "\t|" << frame[j] << "|";
	      j++;
	    }
	}
      i++;
    }
  cout << "\n\t***\n";
  cout << "\n\t Page Fault:" << count;
  return 0;
}

Sortie

 Enter no of pages for which you want to calculate page faults:>
	 Enter the Reference String:
	 Enter the Number of frames:
	***

	 Page Fault:0

Programme C++ utilisant l'indexation et la pagination avec l'algorithme LRU pour rechercher les défauts de page en utilisant des fonctions de hachage pour la gestion de la mémoire dans le système d'exploitation

Lors du suivi de page, une erreur de page se produit lorsque le code tente d'accéder à une page mémoire qui n'existe pas dans la RAM ou n'est pas répertoriée. Pour expliquer le processus, nous suivrons les étapes mentionnées ci-dessous.

• Répétez le processus et référencez la page.

• Supprimer le courant.

• Ajout d'erreurs de page.

• Ajouter le contenu actuel à la page.

• Supprimez le premier de la page.

• Utilisez des chaînes hachées.

• Renvoyer le nombre de clics sur la page sous forme de nombre

示例代码2

//C++ program to find page faults by using indexes with LRU algorithm attached with the paging for memory management in Operating System using hashing function
#include<bits/stdc++.h>
using namespace std;
int pageFaults(int pages[], int n, int capacity)
{
	unordered_set<int> s;
	unordered_map<int, int> indexes;
	int page_faults = 0;
	for (int i=0; i<n; i++)
	{
		if (s.size() < capacity)
		{
			if (s.find(pages[i])==s.end())
			{
				s.insert(pages[i]);
				page_faults++;
			}
			indexes[pages[i]] = i;
		}
		else
		{
			if (s.find(pages[i]) == s.end())
			{
				int lru = INT_MAX, val;
				for (auto it=s.begin(); it!=s.end(); it++)
				{
					if (indexes[*it] < lru)
					{
						lru = indexes[*it];
						val = *it;
					}
				}
				s.erase(val);
				s.insert(pages[i]);
				page_faults++;
			}
			indexes[pages[i]] = i;
		}
	}

	return page_faults;
}
int main()
{
	int pages[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2};
	int n = sizeof(pages)/sizeof(pages[0]);
	int capacity = 4;
	cout << pageFaults(pages, n, capacity);
	return 0;
}

输出

6

结论

最近最少使用（LRU）替换算法是一种特定的页面算法，我们可以使用它比任何其他算法更长的时间。该过程返回较少的页面错误，并能够完成页面分析。在本文中，我们学习了分页过程及其应用。通过使用上述提到的算法和语法，我们已经创建了一些代码以高效地解决问题陈述。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!