ALGORITHME D'ORDONANCEMENT

#include<stdio.h>
//*****************************************************
//structure de donnée sur l'etat de la memoire
#define NUMBER_FRAMES 10;
struct memorystatetype {
	char state; 	//libre 1 alloue 0
	int page; 	//numero de page logique si alloue

};
struct memorystatetype memorystate[10];
//*****************************************************
//structure de donnée sur la table de page
#define NUMBER_PAGES 20;
struct pagetabletype {
	int frame; 	//numero page physique
	char in;	//bit de validité 1:in 0:out
	char reference;	//bit de reference
	//int loadtime;
	long loadtime;	//temps de chargement
	//int lastreferencetime;
	long lastreferencetime;//temps derniers reference
	char dirty;	//bit de modification
	};

struct pagetabletype pagetable[20];
//*****************************************************
//STRUCTURES DE DONNÉES SUR LA CHAINE DE REFERENCE
#define max_references 30;
struct referencestringtype {
	int page;	//la page referencee
	char accessmode;   // lecture 0 ecriture 1
	};

struct referencestringtype referencestring[30];

 //*****************************************************
//initialisation
//initialiser la memoire
void initmem(int m)
{int i;
for(i=1;i<=m;i++)
{
	memorystate[i].page=-1;
	memorystate[i].state=0;
}
}
//*****************************************************
 //initialiser la table des pages TCP
void initTCP(int k)
{
int i;
for (i=1;i<=k;i++)
{
	pagetable[i].frame=-1;
	pagetable[i].in=0;
	pagetable[i].reference=0;
	pagetable[i].loadtime=0;
	pagetable[i].lastreferencetime=0;
	pagetable[i].dirty=0;
}
}


//*****************************************************
//procedure de l'affichage de l'etat de la memoire
void memorystatedraw(int test, int m, int ref)
{
	int i;
	//switch (test)
	{ 	if (test==-1) {	//printf("|        ");
				printf("%d",ref);
					  printf("                             ");
				printf("               référence incorrecte    \n");
				  }
		if (test==0)  {	//printf("Page référencée n° ");
				printf("        ");
				printf("%d", ref);

			  printf("                      ");
				for (i=1; i<=m; i++)
				{
					if (memorystate[i].page==-1)
						printf(" ");
					else
						printf("%d", memorystate[i].page);
					printf("     ");
				}
				printf("        succes             \n");
				 }
		if (test==1) {	//printf("Page référencée n° ");
					  printf("        ");
				printf("%d",ref);
						//printf("      Etat de la mémoire    | ");
			  printf("                    ");
						for (i=1; i<=m; i++)
						{
					if (memorystate[i].page==-1)
											printf(" ");
										else
						printf("%d", memorystate[i].page);
							printf("     ");
						}
					printf("     echec                   \n");
						}
	}
}

//*****************************************************
//intialisee la chaine de reference
void initrefstring(int n)
{int i;
//intialisee la chaine de reference
for (i=1;i<=n;i++)
{
	referencestring[i].page=-1;
}
}


 //*****************************************************
//fonction de choix de l'algoithme de remplacement
int choixalgo(int choix)
{
	printf("\n\n                                                        \n");
	printf("         Algorithmes  de  remplacement\n");
	printf("                                                          \n\n");
	printf("         Pour    F I F O                 Tapez   1\n");
	printf("         Pour    L R U                   Tapez   2\n");
	printf("         Pour    F I F O  2ieme chance    Tapez   3\n");
	printf("                                                  \n");
	printf("         Donner votre choix : ");
choix:	scanf("%d",&choix);
return (choix);
}

 //*****************************main*********************//

int main()
{
int n,m,k,i,x,choix,e,p,frame,victime,pl;
char rep,rep2;
int test,j;
 //******************************************************
printf("\n  **********************************************************\n");
printf("  ******Simulation de la memoire virtuelle******************\n");
printf("  **********************************************************\n\n");
rep='p';
rep2='p';
e=0;
n=0;

printf("donnez le nombre de cadre de page : ");
scanf("%d",&m);
initmem(m);

printf("donnez le nombre de page logique : ");
scanf("%d",&k);
initTCP(k);

		printf("donnez le nombre de reference : ");
			scanf("%d",&n);

				printf("entrez votre chaine de reference \n");
			for (i=1; i<=n;i++)
			{
			printf("N° de page : ");
			scanf("%d",&referencestring[i].page);


	}
//*****************************************************
	choix=choixalgo(choix);

//*****************************************************
// affichage
	printf("\n\n\n\n                                                    \n");
	printf("  Page référencée n° : ");
	printf("     Etat de la mémoire:    ");
	printf("   resultat :              \n");
	printf("                                                            \n");

//*****************************************************
	//parcourir les m peremiere reference
	//on aura surement m echec au depart

	e=0;
	for (x=1; x<=m; x++)
	{	e=e+1;
	pl=referencestring[x].page;
	memorystate[x].page= pl;
	pagetable[pl].frame= x;
	pagetable[pl].in=1;
	pagetable[pl].loadtime=x;   //time();
	pagetable[pl].lastreferencetime=x;
	if (referencestring[x].accessmode==1)
	pagetable[pl].dirty=1; //bit de modification
	else
	pagetable[pl].dirty=0;
	memorystatedraw(1,m,referencestring[x].page);
	}
//*****************************************************
	//parcourir la chaine de reference apres les m 1ere references
	for (i=m+1; i<=n; i++)
	{	test=-1;
	for (x=1; x<=k; x++)
	{  if (x==referencestring[i].page)
		{
		if (pagetable[x].in==1) test=0;
			else  test=1;
			}
	}
	//switch (test)
	//{	// reference incorrecte
		if (test==-1)
//*******************************************************
		//reference incorrecte
			{
			memorystatedraw(-1,m,referencestring[i].page);
			}
 //*******************************************************
		// cas de succes
		if (test==0)
			{
			p = referencestring[i].page;
			pagetable[p].lastreferencetime=i;   //time();
			pagetable[p].reference=1;
			memorystatedraw(0,m,referencestring[i].page);
			}

	if (test==1)
//****************************************************
	{	// defaut de page
		//case 1:	{
			p = referencestring[i].page;
						pagetable[p].lastreferencetime=i; //time();
								pagetable[p].reference=1;
			e=e+1;
//*******************************************************
//choix du l'algorithme de remplacement
			//switch (choix)
			// algo fifo
			if (choix==1)
					{
					//victime=replaceFIFO(k,frame);
					//printf("%d",victime);
					victime=memorystate[1].page;
					frame=pagetable[victime].frame;
					//chercher celle qui a le temps de chargement + ancien
					for (j=1; j<=k; j++)
					{
					if(pagetable[j].in==1)
					if (pagetable[j].loadtime < pagetable[victime].loadtime)
						{
						victime=j;
						frame=pagetable[j].frame;
						}
					}
				}
//**************************************************************
				//case 2:{  //replaceLRU;
			if (choix==2)
					{
					victime=memorystate[1].page;
													 frame=pagetable[victime].frame;
					//chercher celle qui a le temps de reference le + ancien
					//ça veut dire la moins recement utilisée
					for (j=1; j<=k; j++)
					{
					if(pagetable[j].in==1)
					if (pagetable[j].lastreferencetime < pagetable[victime].lastreferencetime)
						{
						victime=j;
						frame=pagetable[j].frame;
									}
								}
					}// fin case 2
 //************************************************************
	//algo 2 ieme chance
						  //case 3:  victime=replaceclock(k,frame);
			if (choix==3)
			{
		//	memorystatedraw(0,m,referencestring[i].page);
				victime =-1;
				while (victime==-1)
				//chercher celle qui a le temps de chargement + ancien
					{
				for (j=1; j<=k; j++)
						{
					printf("\npage:");
					printf("%d",j);
					printf("\nframe:");
													printf("%d",pagetable[j].frame);
					printf("\nin:");
													 printf("%d",pagetable[j].in);
					printf("\ncharge:");
					printf("%d",pagetable[j].loadtime);
					printf("\nref :");
					printf("%d",pagetable[victime].reference);

					if(pagetable[j].in==1)
					if ((victime==-1) || (pagetable[i].loadtime < pagetable[victime].loadtime))
									{
							victime=j;
									frame=pagetable[j].frame;
							}

						//si cette page est référencée on lui donne une 2eme chance
					if (pagetable[victime].reference==1)
							{
						printf("victime");
						printf("\n%d",victime);
						pagetable[victime].loadtime=i-1;   //time();
						printf("\niiii ");
						printf("%d",i);
							pagetable[victime].reference=0;
								victime=-1;

						}
					}

			} }

	//********************************************************
	//mettre a jour le TCP
				frame = pagetable[victime].frame;
				pl=referencestring[i].page;
					memorystate[frame].page= pl;
					pagetable[pl].frame = frame;
					pagetable[pl].in=1;
					pagetable[pl].loadtime=i;
					if (referencestring[i].accessmode==1)
					pagetable[pl].dirty=1; //bit de modification
				else
					{	pagetable[pl].dirty=0;
							pagetable[victime].in=0;
				}
				printf("\n");
				memorystatedraw(1,m,referencestring[i].page);
				printf("\nvictime ");
			printf("%d",victime);
			printf("\nframe ");
			printf("%d",frame);


				}

	test=-1;
	printf("                                                                 \n");
   //*****************************************************
	printf("le nombre de defaut de page est : %d\n",e);


}}