int main() {
struct ABR *dico;
dico = make(1, 0, 0);
insere(dico, 17);
insere(dico, 5);
insere(dico, 8);
print_string(to_string(dico));
putchar(10);
if (contient(dico, 5) && !contient(dico, 0) &&
contient(dico, 17) && !contient(dico, 3))
print_string("ok\n");
insere(dico, 42);
insere(dico, 1000);
insere(dico, 0);
print_string(to_string(dico));
putchar(10);
}
/*
* Insère un nouveau mot dans la hash table, si celui-ci ne s'y trouve pas encore
* @param mot : le mot à insérer
* @param dico : la hash table dans laquelle ajouter mot
* @return : la hash table mise à jour
*/
HashTable* insere(Mot mot, HashTable* dico)
{
int index, contains ;
contains = contient(dico, mot.mot) ;
/* Retourner la table inchangée si le mot s'y trouve déjà */
if(contains)
return dico ;
index = hash(mot.mot) ;
dico->contenu[index] = add(mot, dico->contenu[index]) ;
return dico ;
}
//algo_optimal: simule le remplacement des pages selon l'algorithme optimal.
//Pour ce faire, lors d'un remplacement de pages on regarde dans la suite
//des pages demandées pour trouver le meilleur remplacement, celui qui, soit
//ne revient, soit qui revient le plus tard possible. Je préfère chercher
//le cadre optimal à changer lorsqu'il le faut plutôt que garder un tableau
//pour chaque cadre.
struct memoire_physique * algo_optimal(struct ref_processus* pages, int cadres) {
struct memoire_physique* mem = initialiser_memoire(cadres, OPTIMAL);
int vide = 0, //indique la position du prochain cadre libre,
//s'il y en a un
max_proche, //distance et position maximale de la prochaine
pos_max, //demande de page
prochOcc, i, j;
for(i = 0; i < pages->nbre_ref; ++i) {
//Debut: on regarde si la page n'est pas présente. Si elle est
//présente, rien à faire.
if(contient(mem, pages->references[i]) < 0) {
mem->nbre_defauts_pages++;
//A-t-on un cadre libre?
if(vide < mem->nbre_cadres) {
pos_max = vide++;
} else {
//On trouve le remplacement optimal
max_proche = -1;
for(j = 0; j < mem->nbre_cadres; ++j) {
//On trouve la prochaine occurence de cette page
prochOcc = trouver_proch_occ(pages, i, mem->cadres[j].page);
if(prochOcc < 0) {
pos_max= j;
break;
}
if(max_proche < prochOcc) {
max_proche = prochOcc;
pos_max = j;
}
}
}
//On a maintenant l'endroit pour ecraser, on fait le changement
mem->cadres[pos_max].page = pages->references[i];
}
} //fin for
return mem;
}
//algo_horloge: simule le remplacement des pages selon l'algorithme de
//l'horloge. Il y a deux niveaux de vérification effectuées lors d'un
//défaut de page. Premièrement, on vérifie s'il reste un cadre vide.
//Si tous les cadres sont occupés, on cherche alors le premier cadre
//ayant une valeur de R = 0.J'utilise les valeurs entières de 0 et 1 pour
//R. On pourrait changer les valeurs, mais ces valeurs fonctionnent
//pour la fonction qui affiche le résultat.
struct memoire_physique* algo_horloge(struct ref_processus *pages, int cadres) {
int courant = 0, //position du prochain cadre vide, seulement pour
//les premiers cadres.
vide = 0,
i,
retour; //position dans les cadres d'une page, si elle est
//présente
struct memoire_physique* mem = initialiser_memoire(cadres, HORLOGE);
//On traite les demandes de pages
for(i = 0; i < pages->nbre_ref; ++i) {
//On vérifie si la page est déjà dans un cadre
if((retour = contient(mem, pages->references[i])) >= 0 ) {
mem->cadres[retour].R = R_1;
} else {
//défaut de page
if(vide < mem->nbre_cadres) {
courant = vide++;
} else {
//On trouve la position de la victime. Soit un cadre vide,
//soit le premier cadre ou R == R_0
while(mem->cadres[courant].R != R_0) {
mem->cadres[courant].R = R_0;
courant = (courant+1)%mem->nbre_cadres;
}
}
//Maintenant on a la position ou changer la valeur
mem->nbre_defauts_pages++;
mem->cadres[courant].page = pages->references[i];
mem->cadres[courant].R = R_1;
courant = (courant +1)%mem->nbre_cadres;
}
}
return mem;
}
void exemple(cv::VideoCapture capture)
{
cv::Mat frame, copie;
char key;
while(key != 'q')
{
std::cout << "frame" << std::endl;
std::vector<cv::Rect> triangles, squares;
capture >> frame;
copie = frame.clone();
contours(copie);
for(unsigned int i = 0; i < squares.size(); i++)
{
for(unsigned int j = 0; j < triangles.size(); j++)
{
if(contient(squares[i], triangles[j]))
std::cout << "Face détectée, coin haut gauche : " << squares[i].tl() << "coin bas droit : " << squares[i].br() << std::endl;
}
}
key = cv::waitKey(1);
}
return;
}
int contient(struct ABR *a, int x) {
if (x == a->valeur) return 1;
if (x < a->valeur && a->gauche != 0) return contient(a->gauche, x);
if (a->droite != 0) return contient(a->droite, x);
return 0;
}
//algo_vieillissement: Simule l'algorithme de remplacement de pages
//vieillissement. La valeur de R ici est représentée par un octet, donc
//un char. Toutefois, le char dans la structure est signée, donc j'utilise
//une valeur temporaire afin de plus facilement mettre à jour les valeurs
//de R lors d'un défaut de page ou alors à la fin d'un cycle.
struct memoire_physique * algo_vieillissement(struct ref_processus* pages,
int cadres, int cycle)
{
struct memoire_physique* mem = initialiser_memoire(cadres, VIEILLISSEMENT);
int vide = 0, //position du prochain cadre libre, s'il y en a un
min, //min: plus petite valeur de R
pos, //position de min
i, j,
retour;
int pos_cycle= 0;
unsigned char temp; //permet de facilement mettre a jour la valeur
//de vieillissement d'un cadre
char *maj = (char*)malloc(cadres*sizeof(char));
if(!maj) {
fprintf(stderr, "Erreur lors d'une allocation de memoire dynamique.\n");
exit(1);
}
for(i = 0; i < cadres; ++i) {
maj[i] = 0;
}
for(i = 0; i < pages->nbre_ref; ++i) {
//debut: on regarde si la page est dans un des cadres
if((retour = contient(mem, pages->references[i])) >= 0) {
maj[retour] = 1;
}
++pos_cycle;
//si on a defaut de page ou on a un clock tick, on met à jour
//les R
if(retour < 0 || pos_cycle >= cycle) {
for(j = 0; j < cadres; j++) {
temp = mem->cadres[j].R;
temp = temp >> 1; //shift a droite d'une position
if(maj[j] != 0) {
temp += R_10000000; //0x10000000
}
mem->cadres[j].R = temp;
maj[j] = 0;
}
pos_cycle = 0;
}
//Maintenant, on regarde s'il y a defaut de page.
if(retour < 0) {
//Debut: on regarde si un cadre ne contient pas de pages
mem->nbre_defauts_pages++;
if (vide < cadres) {
pos = vide++;
} else {
min = MAX_R; //Nom de var à changer
//Si on a pas de cadres libres, on choisit la victime
for(j = 0; j < cadres; j++) {
temp = mem->cadres[j].R;
if (temp < min) {
min = temp;
pos = j;
if(min <= 0)
break;
}
}
}
//Maintenant on remplace
mem->cadres[pos].page = pages->references[i];
mem->cadres[pos].R = R_10000000;
} //fin if
} //fin for exterieur
free(maj);
return mem;
}