Commit 93ab10a5 authored by Hugo's avatar Hugo
Browse files

partie 3 avance

parent 7277e2ac
......@@ -21,7 +21,13 @@ void *mark_memarea_and_get_user_ptr(void *ptr, unsigned long size, MemKind k)
{
//calcul magic
uint64_t magic;
magic = knuth_mmix_one_round((unsigned long)ptr) & ~(0b11UL);
// if(size>=LARGEALLOC){;}
// else if(size<=SMALL){;}
// else{;}
// magic = knuth_mmix_one_round((unsigned long)ptr) & ~(0b11UL);
if(k == LARGE_KIND){magic = knuth_mmix_one_round((unsigned long)ptr) & 0xfffffffffffffffe;magic |= 0x0000000000000002;}
else if(k==MEDIUM_KIND){magic = knuth_mmix_one_round((unsigned long)ptr) & 0xfffffffffffffffd;magic |= 0x0000000000000001;}
else{magic = knuth_mmix_one_round((unsigned long)ptr) & 0xfffffffffffffffc; }
//marquage du bloc
char* pointeur = NULL;
pointeur = (char*)ptr;
......@@ -44,8 +50,12 @@ mark_check_and_get_alloc(void *ptr)
//on renseigne les valeurs de a a retourner
a.ptr = (void*)pointeur;
a.size = *(unsigned long*)a.ptr;
a.kind = (MemKind)(magicLu<<62 );assert(a.kind==0x0);
uint64_t magicParCalcul = knuth_mmix_one_round((unsigned long)((void*)pointeur)) & ~(0b11UL);
a.kind = (MemKind)(magicLu & 0x00000003);
// uint64_t magicParCalcul = knuth_mmix_one_round((unsigned long)((void*)pointeur)) & ~(0b11UL);
uint64_t magicParCalcul;
if(a.kind == LARGE_KIND){magicParCalcul = knuth_mmix_one_round((unsigned long)pointeur) & 0xfffffffffffffffe;magicParCalcul |= 0x0000000000000002;}
else if(a.kind==MEDIUM_KIND){magicParCalcul = knuth_mmix_one_round((unsigned long)pointeur) & 0xfffffffffffffffd;magicParCalcul |= 0x0000000000000001;}
else{magicParCalcul = knuth_mmix_one_round((unsigned long)pointeur) & 0xfffffffffffffffc; }
assert(magicLu == magicParCalcul) ;//verifie magic
char* pointeur2 = (char*)(pointeur+a.size-16);//pointeur2 pointe vers l'octet du debut de marquage de fin
assert(*((unsigned long *)(pointeur))== *((unsigned long *)(pointeur2+8)));//verifie marquage debut = marquage fin
......
......@@ -21,62 +21,108 @@ unsigned int puiss2(unsigned long size) {
return p;
}
void addliste(void *ptr, int size){//en argument : bloc a l'adresse ptr de taille 2**size
void**A = &arena.TZL[size];
void**B = (ptr+16);
*B= (void*)arena.TZL[size];//on ajoute la cellule au début de la chaine
*A=(void*)ptr;
int power(int n, int k){
assert(k>=0);
int b=1;
for(int a=0;a<k;a++){
b*=n;
}
return b;
}
void chunkcut(unsigned int size_dest,unsigned int size){
void addliste(void *ptr, int indice_size){//en argument : bloc a l'adresse ptr de taille 2**indice_size
void**B = ptr;
*B= (void*)arena.TZL[indice_size];//on chaine la nouvelle cellule
void**A = &arena.TZL[indice_size];
*A=(void*)ptr;//on ajoute la niuvelle cellule en tete de liste
}
if(size==size_dest){
return;
int chunkcut(unsigned int indice_dest,unsigned int indice){//en argument : bloc de taille 2**size a decouper en blocs de taille 2**size_dest
assert(indice>=indice_dest);
if(indice==indice_dest){//on arrive a la bonne taille
return 1;
}
else{
void *ptr = arena.TZL[size];
//pour la premiere case découpé
*(uint16_t*)ptr=(uint16_t)size/2;
addliste(ptr,size/2);
//pour la deuxieme case découpé
*(uint16_t*)(ptr+size/2)=(uint16_t)size/2;
addliste(ptr+size/2,size/2);
chunkcut(size_dest,size/2);
else{//on observe le bloc indice
if(arena.TZL[indice]==NULL){return 0;}//si il n'y a pas de bloc de taille indice
else{//si il y a au moins un bloc :
void *ptr = arena.TZL[indice];
addliste(ptr+(unsigned int)power(2,indice-1),indice-1);//ajout case2 a la liste contenant des taille indice/2
addliste(ptr,indice-1);//ajout case1 a la liste contenant des taille indice/2
void**A = &arena.TZL[indice];
*A = (void*)((unsigned long)*(unsigned long*)arena.TZL[indice]);//on retire le bloc1+bloc2 de la listye contenant des tailles indice
return chunkcut(indice_dest,indice-1);;
}
}
}
void *
emalloc_medium(unsigned long size)
{/*
void * emalloc_medium(unsigned long size){
assert(size < LARGEALLOC);
assert(size > SMALLALLOC);
unsigned int index=puiss2(size);
unsigned long SizeWithMark = size+32;
unsigned int index=puiss2(SizeWithMark);
//si un bloc est dispo
if(arena.TZL[index]!=NULL)
{
return arena.TZL[index];
void* bloc1 = (void*)((unsigned long)arena.TZL[index]);//bloc1 : adresse du premier bloc de la liste pointee par TZL[indice]
arena.TZL[index]=(void*)(*(uint64_t*)(bloc1));
// void **A = &arena.TZL[index]
// *A = (void*)(*(unsigned long*)bloc1);//TZL[indice] pointe désormais vers le bloc 2 d'adresse (*(unsigned long*)bloc1)
void *ptr = mark_memarea_and_get_user_ptr(bloc1,SizeWithMark,MEDIUM_KIND);
Alloc B = mark_check_and_get_alloc(ptr);
assert(B.kind == MEDIUM_KIND);
return ptr;
}
//Si aucun bloc dispo
else{
unsigned int index_sup=2*index;
chunkcut(index_sup,index);
}*/
return (void *) 0;
unsigned int index_sup=1+index;
unsigned int cut=0;
//si il y a un bloc dispo apres
while(cut == 0&& index_sup<(FIRST_ALLOC_MEDIUM_EXPOSANT + arena.medium_next_exponant)){
if(arena.TZL[index_sup]!=NULL){chunkcut(puiss2(size), index_sup);cut=1;}
else{index_sup++;}
}
//si il y a aucun bloc dispo apres
if(cut==0){
mem_realloc_medium();
assert(chunkcut(puiss2(size),FIRST_ALLOC_MEDIUM_EXPOSANT + arena.medium_next_exponant-1));
}
return emalloc_medium(size);
}
}
int search_element(void* adress, void* list, unsigned long size){
return 0;
}
void efree_medium(Alloc a) {/*
void* buddy_address= a. ptr^ a. size:
void* ptr_parcours =arena.TZL[size];
void** ptr_address=&(a.ptr+16);
void efree_medium(Alloc a) {
//initialisation variables
void* buddy_address= (void*)((unsigned long)a.ptr ^ a. size);//calcul de l'adresse du buddy
void* ptr_parcours =arena.TZL[puiss2(a.size)];//pointeur sur la liste contenant les element de la meme taille que a
void* ptr_prec =arena.TZL[puiss2(a.size)];//pointeur sur la liste sur l'element avant celui pointe par ptr_parcours
while(ptr_parcours!=NULL){
if(ptr_parcours==buddy_address){
a.size=(uint32_t)(2*a.size);//on fusionne a et son buddy
//on sort le buddy de la liste
void** A = arena.TZL[puiss2(a.size)];
*A = (void*)((void*)(*(unsigned long*)ptr_parcours));
//IL MANQUE A FREE LE NOUVEAU A A LA PROCHAINE LISTE
efree_medium(a);
return;
}
else{ptr_parcours = (void*)(*(unsigned long*)ptr_parcours);}//on passe a l'element suivant de la liste
while(ptr_parcours!=NULL ){
if(ptr_parcours==buddy_address){// si le buddy est libre, on le fusionne avec son bloc de départ
a.size=(uint32_t)2*size;
*ptr_address=*(buddy_address+16); // le bloc suivant le nouveau bloc issu de la fusion sera le bloc qui suivait le buddy
a.size=(uint32_t)(2*a.size);//on fusionne a et son buddy
*(unsigned long*)ptr_prec =*(unsigned long*)ptr_parcours; //on sort le buddy de la liste
efree_medium(a);
return;
}
else{
// ajout du bloc buddy dans la liste
addliste(buddy_address,a.size);
else{//si ce n'est pas le buddy on passe a l'element suivant
ptr_prec = ptr_parcours;
ptr_parcours = (void*)(*(unsigned long*)ptr_parcours);
}
}*/
}
void **B = ptr_prec; //ajout du bloc a la fin de la liste
*B = (void*)a.ptr;
}
......@@ -9,21 +9,6 @@
#include "mem_internals.h"
#include <inttypes.h>
// list_chunk creer_list(){
// // list_chunk list;
// // list_chunk parcours = malloc(sizeof(small_chunk));
// // list = parcours;
// void * address=arena.chunkpool;
// while(address+96!=NULL){
// parcours->address=address;
// address+=96;
// parcours->next=malloc(sizeof(small_chunk));
// parcours = parcours->next;
// }
// return list;
// }
void *
emalloc_small(unsigned long size)
{
......@@ -57,12 +42,5 @@ void efree_small(Alloc a) {
*A = (void*)(*(uint64_t*)arena.chunkpool);
//ajoute a en tete de liste
arena.chunkpool = a.ptr;
/*
void** ptr_tampon = &arena.chunkpool;//enregistre ancienne valeur du chunkpool
arena.chunkpool=a.ptr;//on ajoute la callule a a la liste
*(int16_t*)arena.chunkpool=(int16_t)a.size;//on ecrit sa taille
*ptr_tampon = (void*)(arena.chunkpool+16);//on la chaine avec le reste de la liste grace au ptr_tampon
*/
}
//*(int16_t*)(arena.chunkpool+16)=*(int16_t*)ptr_tampon;
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment