public void AjouterAIndice(PageCase p, int indice)
{
ListMemoire[indice] = p;
if (MemoireVide)
{
MemoireVide = false;
}
}
public override string DeroulerAlgorithme()
{
//temps d'attente entre les instructions de l'algorithme
//Tant que la file entrée par l'utilisateur n'est pas terminée
//while (base.GetTailleListeUtilisateur() != 0)
string[] arr = new string [4];
Console.WriteLine(time++);
//Récupérer la tête de la liste entrée par l'utilisateur
PageCase pageCourante = GetListei(0);
//Liberer la tete de la liste
SuppDeListe(0);
//Vérifier que la page est déjà en mémoire physique
if (!PageExiste(pageCourante.GetNumeroPage()))
{
//******************************************************************************************
// la page n'existe pas
String pg = Convert.ToString(pageCourante.GetNumeroPage());
arr[0] = " La page" + " " + pg + " " + "n’existe pas en mémoire (défaut de page ) ";
//********************************************************************************************/
SetDefautPages(GetDefautPage() + 1);
//Enfiler la pageCourante
FileFIFO.Enqueue(pageCourante);
//Si la mémoire physique n'est pas entièrement remplie
if (!MemoirePleine())
{
//********************************************************************************
// n = "not full" => la memoire n'est pas pleine
arr[1] = " et la mémoire n’est pas pleine :" + "\n" + "- la page"+ " " + pg + " " + " est chargée dans la première case vide.";
//********************************************************************************
//Charger la page à la première case vide
pageCourante.SetNumeroCase(PremiereCaseLibre());
//ajouterAMemoire(pageCourante);
RemplacerDansMemoire(pageCourante, PremiereCaseLibre());
//Décrémenter le nombre de cases libres en mémoire physique
DecCasesLibre();
}
//Si la mémoire physique est entièrement remplie
else
{
//******************************************************************************
// f = "full" => la memoire est pleine
//******************************************************************************
//utiliser l'algorithme de remplacement FIFO
pageCourante.SetNumeroCase(PageAReplacer());
RemplacerDansMemoire(pageCourante, PageAReplacer());
//specifier le numero de page a remplacer et le rajouter dans la chaine retourner en sortie
String pr = Convert.ToString(PageAReplacer());
arr[1] = "et la mémoire est pleine" + "\n" + "Remplacement de la page selon FIFO:" + "\n" + "- Défiler la file(récupérer la page qui a été entrée en premier) =" + pr;
//Defiler la page remplacer
FileFIFO.Dequeue();
}
}
else
{
//**************************************************************************************
// p = "present" => la page est presente
String pag = Convert.ToString(pageCourante.GetNumeroPage());
arr[0] = " La page" + " " + pag + " " + "existe déjà en mémoire ";
//indiquer le numero de page existante deja et la rajouter dans la chaine
//**************************************************************************************
}
string result = arr[0] + " " + arr[1];
return(result);
}
public override string DeroulerAlgorithme()
{
string[] arr = new string[4];
int pageAR;
//parcourir la liste de page
//while (ConditionContinuer())
//Récupérer la tête de la liste entrée par l'utilisateur
PageCase pageCourante = GetListei(0);
//Liberer la tete de la liste
SuppDeListe(0);
//Sauvegarder le numéro de la page
DernierePage = pageCourante.numeroPage;
if (MemoirePhysique.MemoireVide)
{
TablePage.PagePetitCompteur = pageCourante.numeroPage;
}
//Mettre le Ri de la page courante à 1
TablePage.ListeTB[pageCourante.numeroPage].Ri = 1;
//Si la page n'est pas présente en mémoire
if (!PageExiste(pageCourante.GetNumeroPage()))
{
//********************************************************************************************
String pg = Convert.ToString(pageCourante.GetNumeroPage());
arr[0] = " La page" + " " + pg + " " + "n’existe pas en mémoire (défaut de page ) ";
//********************************************************************************************
//incrémenter le nombre de défauts de page
SetDefautPages(GetDefautPage() + 1);
//Si la mémoire physique n'est pas entièrement pleine
if (!MemoirePleine())
{
//**********************************************************************************
arr[1] = " et la mémoire n’est pas pleine :" + "\n" + "- la page"+ " " + pg + " " + " est chargée dans la première case vide." + "\n" + " Dans la table de page :"+ "\n" + "- Bit de présence de la page chargée en mémoire mis a 1." + "\n" + "- Mettre le registre Compteur Ci a 1(a droite)« 1000 0000 »" + "\n" + "- Décalage a droite de tout les Ri(Registre de référence)." + "\n" + "- Rajouter Ri au Ci." + "\n" + "- Mettre a jour la case correspondante a la page.";
//*********************************************************************************
//Charger la page à la première case vide
pageCourante.SetNumeroCase(PremiereCaseLibre());
//Mettre à jour le numéro de case de la page -dans la table de page-
TablePage.ListeTB[pageCourante.numeroPage].NumeroCase = PremiereCaseLibre();
RemplacerDansMemoire(pageCourante, PremiereCaseLibre());
//Décrémenter le nombre de cases libres en mémoire physique
DecCasesLibre();
}
else
{
//******************************************************************************
//******************************************************************************
pageCourante.SetNumeroCase(PageAReplacer());
//Mettre à jour le numéro de case de la page -dans la table de page-
TablePage.ListeTB[pageCourante.numeroPage].NumeroCase = TablePage.ListeTB[PageAReplacer()].NumeroCase;
pageAR = PageAReplacer();
//specifier le numero de page a remplacer et le rajouter dans la chaine retourner en sortie
String pr = Convert.ToString(PageAReplacer());
arr[1] = "et la mémoire est pleine" + "\n" + "Remplacement de la page selon AGING:" + "\n" + "- La page qui a le Ci le plus petit est remplacée.(" + pr + ")" + "\n" + "Dans la table de page:" + "\n" + " -Bit de présence de la page chargée en mémoire mis a 1" + "\n" + "- Mettre le registre Compteur Ci a 1(a droite)« 1000 0000 »" + "\n" + "- Décalage a droite de tout les Ri(Registre de référence)." + "\n" + "- Rajouter Ri au Ci." + "\n" + "- Mettre a jour la case correspondante a la page.";
TablePage.ListeTB[pageAR].NumeroCase = -1;
//TablePage.ListeTB[pageAR].Compteur = 0;
RemplacerDansMemoire(pageCourante, TablePage.ListeTB[PageAReplacer()].NumeroCase);
}
}
else
{
//***********************************************************************************
//**************************************************************************************
String pag = Convert.ToString(pageCourante.GetNumeroPage());
arr[0] = " La page" + " " + pag + " " + "existe déjà en mémoire " + "\n" + " Dans la table de page:"+ "\n" + "-Mettre le registre Compteur Ci a 1(a droite)« 1000 0000 »" + "\n" + "-Décalage a droite de tout les Ri(Registre de référence)." + "\n" + "-Rajouter Ri au Ci.";
}
string result = arr[0] + " " + arr[1];
return(result);
}
static void Main(string[] args)
{
//Creation de 8 pages
PageCase p0 = new PageCase(0);
PageCase p1 = new PageCase(1);
PageCase p2 = new PageCase(2);
PageCase p3 = new PageCase(3);
PageCase p4 = new PageCase(4);
PageCase p5 = new PageCase(5);
PageCase p6 = new PageCase(6);
PageCase p7 = new PageCase(7);
//***** LFU *****//
//Creation d'un systeme LFU
/* SystemLFU lfu = new SystemLFU(1024, 128, 512); //768 étant la taille de mémoire physique et 256 la taille de la case/page mémoire
*
* //Charger la liste de l'utilisateur
* lfu.ajouterAListe(p2);
* lfu.ajouterAListe(p0);
* lfu.ajouterAListe(p3);
* lfu.ajouterAListe(p2);
* lfu.ajouterAListe(p0);
* lfu.ajouterAListe(p5);
* lfu.ajouterAListe(p7);
* lfu.ajouterAListe(p1);
* lfu.ajouterAListe(p3);
* lfu.ajouterAListe(p1);
* lfu.ajouterAListe(p6);
*
* //Simuler la gestion avec algorithme LFU
* lfu.deroulerAlgorithme(); */
//-**** Aging *****-//
//Creation d'un systeme Aging
// SystemeAging aging = new SystemeAging(64, 32, 16); //768 étant la taille de mémoire physique et 256 la taille de la case/page mémoire
//SystemeLFU lfu = new SystemeLFU(64, 32, 16);
//Charger la liste de l'utilisateur
/*aging.AjouterAListe(p2);
* aging.AjouterAListe(p0);
* aging.AjouterAListe(p3);
* aging.AjouterAListe(p2);*/
/*lfu.AjouterAListe(p2);
* lfu.AjouterAListe(p0);
* lfu.AjouterAListe(p3);
* lfu.AjouterAListe(p2);*/
SystemeAging aging = new SystemeAging(32, 12, 4);
aging.AjouterAListe(p0);
aging.AjouterAListe(p0);
aging.AjouterAListe(p2);
int i = 0;
Console.WriteLine("" + aging.ListeUtilisateur.Count);
//Simuler la gestion avec algorithme Aging
while (i < aging.ListeUtilisateur.Count)
{
//Console.WriteLine("heeeere");
string str = aging.DeroulerAlgorithme();
Console.WriteLine("" + str);
Console.ReadLine();
i++;
}
}
public override string DeroulerAlgorithme()
{
//Tant que la file entrée par l'utilisateur n'est pas terminée
//while (base.GetTailleListeUtilisateur() != 0)
//Récupérer la tête de la liste entrée par l'utilisateur
PageCase pageCourante = GetListei(0);
//Liberer la tete de la liste
SuppDeListe(0);
string[] arr = new string[4];
if (PageExiste(pageCourante.GetNumeroPage()))
{
//*******************************************************************************************
// p = "present" => la page existe deja
String pag = Convert.ToString(pageCourante.GetNumeroPage());
arr[0] = "1. La page" + " " + pag + " " + "existe déjà en mémoire " + "\n" + "- elle est supprimée de la liste LRU et est insérée en tête de cette dernière. ";
//********************************************************************************************
/*Supprimer la page de la liste LRU*/
//Récupérer son indice dans la liste
ListeLRU.Remove(pageCourante);
//Inserer la page courante en tête de listei
ListeLRU.Insert(0, pageCourante);
}
else
{
// la page n'existe pas
String pg = Convert.ToString(pageCourante.GetNumeroPage());
arr[0] = "1. La page" + " " + pg + " " + "n’existe pas en mémoire (défaut de page ) ";
//Inserer la page courante en tête de liste
ListeLRU.Insert(0, pageCourante);
SetDefautPages(GetDefautPage() + 1);
//Si la mémoire physique n'est pas entièrement remplie
if (!MemoirePleine())
{
//**********************************************************************************
// n = "not full" => la memoire n'est pas pleine
arr[1] = " et la mémoire n’est pas pleine :" + "\n" + "- la page"+ " " + pg + " " + " est chargée dans la première case vide.";
//*********************************************************************************
//Charger la page à la première case vide
pageCourante.SetNumeroCase(PremiereCaseLibre());
//ajouterAMemoire(pageCourante);
RemplacerDansMemoire(pageCourante, PremiereCaseLibre());
//Décrémenter le nombre de cases libres en mémoire physique
DecCasesLibre();
}
//Si la mémoire physique est entièrement remplie
else
{
//*******************************************************************************
// => la memoire est pleine
//******************************************************************************
//utiliser l'algorithme de remplacement LRU
pageCourante.SetNumeroCase(PageAReplacer());
RemplacerDansMemoire(pageCourante, PageAReplacer());
String pr = Convert.ToString(PageAReplacer());
arr[1] = "et la mémoire est pleine" + "\n" + "Remplacement de la page selon LRU:" + "\n" + "- Récupérer l’emplacement en mémoire physique(numéro de case ) de la page en queue de la liste LRU(la moins récemment utilisée ) ="+ pr;
//Supprimer la page de la liste
ListeLRU.RemoveAt(ListeLRU.Count - 1);
}
}
string result = arr[0] + " " + arr[1];
return(result);
}
public void AjouterAListe(PageCase p)
{
ListeUtilisateur.Add(p);
}
public void RemplacerDansMemoire(PageCase p, int position)
{
MemoirePhysique.AjouterAIndice(p, position);
}
public override string DeroulerAlgorithme()
{
string[] arr = new string[4];
int pageAR;
//parcourir la liste de page
//while (ConditionContinuer())
//Récupérer la tête de la liste entrée par l'utilisateur
PageCase pageCourante = GetListei(0);
//Liberer la tete de la liste
SuppDeListe(0);
//Sauvegarder le numéro de la page
DernierePage = pageCourante.numeroPage;
if (MemoirePhysique.MemoireVide)
{
TablePage.PagePetitCompteur = pageCourante.numeroPage;
}
//Mettre le Ri de la page courante à 1
TablePage.ListeTB[pageCourante.numeroPage].Ri = 1;
//Si la page n'est pas présente en mémoire
if (!PageExiste(pageCourante.GetNumeroPage()))
{
//*******************************************************************************************
// => la page n'existe pas
String pg = Convert.ToString(pageCourante.GetNumeroPage());
arr[0] = "1. La page" + " " + pg + " " + "n’existe pas en mémoire (défaut de page ) ";
//********************************************************************************************
//incrémenter le nombre de défauts de page
SetDefautPages(GetDefautPage() + 1);
//Si la mémoire physique n'est pas entièrement pleine
if (!MemoirePleine())
{
//**********************************************************************************
// => la memoire n'est pas pleine
arr[1] = " et la mémoire n’est pas pleine :" + "\n" + "- la page"+ " " + pg + " " + " est chargée dans la première case vide." + "\n" + "- Incrémentation de sa fréquence ";
//Charger la page à la première case vide
pageCourante.SetNumeroCase(PremiereCaseLibre());
//Mettre à jour le numéro de case de la page -dans la table de page-
TablePage.ListeTB[pageCourante.numeroPage].NumeroCase = PremiereCaseLibre();
RemplacerDansMemoire(pageCourante, PremiereCaseLibre());
//Décrémenter le nombre de cases libres en mémoire physique
DecCasesLibre();
}
else
{
//*******************************************************************************
// la mémoire est pleine.
//******************************************************************************
pageCourante.SetNumeroCase(PageAReplacer());
//Mettre à jour le numéro de case de la page -dans la table de page-
TablePage.ListeTB[pageCourante.numeroPage].NumeroCase = TablePage.ListeTB[PageAReplacer()].NumeroCase;
pageAR = PageAReplacer();
//specifier le numero de page a remplacer et le rajouter dans la chaine retourner en sortie
String pr = Convert.ToString(PageAReplacer());
arr[1] = "et la mémoire est pleine" + "\n" + "- Incrémentation de la fréquence de la page " + pg + "\n" + "Remplacement de la page selon LFU:" + "\n" + "- La page en mémoire physique qui correspond a la fréquence la plus petite est remplacée par " + pg + "\n" + "- S'il existe deux ou plusieurs pages contenant des fréquences égales. La page a remplacer est choisi parmi ces pages par méthode FIFO(la page qui a été entrée en premier)";
TablePage.ListeTB[pageAR].NumeroCase = -1;
//TablePage.ListeTB[pageAR].Compteur = 0;
RemplacerDansMemoire(pageCourante, TablePage.ListeTB[PageAReplacer()].NumeroCase);
}
}
else
{
//**************************************************************************************
// p = "present" => la page est presente
String pag = Convert.ToString(pageCourante.GetNumeroPage());
arr[0] = "1. La page" + " " + pag + " " + "existe déjà en mémoire " + "\n" + "- Incrémentation de la fréquence de la page ";
//**************************************************************************************
}
string result = arr[0] + " " + arr[1];
return(result);
}
public void Ajouter(PageCase p)
{
ListMemoire.Add(p);
}
