MALLOOOOOOOOC

/*
 * fake-malloc.c    -- Implementation de malloc, free, calloc, realloc
 *
 * Implémentation first-fit pour malloc
 *
 *           Author: Erick Gallesio [eg@unice.fr]
 *    Creation date: 11-May-2015 17:26 (eg)
 * Last file update: 11-May-2015 20:55 (eg)
 */

#include <stdio.h>
#include "my-malloc.h"


/* Une version de my-malloc.c qu'il faudra vite remplacer par quelque chose de
 * plus "raisonnable". Ce code n'est juste là que pour pouvoir lancer
 * les programmes de test.
 */
static int nb_alloc   = 0;      /* Nombre de fois où on alloué     */
static int nb_dealloc = 0;      /* Nombre de fois où on désalloué  */
static int nb_sbrk    = 0;      /* nombre de fois où a appelé sbrk */

#define MOST_RESTRICTING_TYPE double
typedef union header {
  struct {
    unsigned int size;
    union header *ptr;
  } info;
  MOST_RESTRICTING_TYPE dummy;
} Header;
static int headerSize = sizeof(Header);
static Header base;


void *mymalloc(size_t size) {
  Header *pnew;
  nb_alloc += 1;
  if(nb_sbrk==0) { // Initialisation de la zone mémoire
    pnew = sbrk(headerSize*101);
    pnew->info.size = size;
    pnew->info.ptr = &base;
    base.info.ptr = pnew;
    nb_sbrk++;
    return pnew;
  }
  pnew = &base;
  while(pnew->info.ptr!=&base) { // On cherche un bloc libre assez gros
    if(pnew->info.size>=(size/headerSize)*headerSize+headerSize) {
      pnew->info.size = pnew->info.size - ((size/headerSize)*headerSize+headerSize);
      return pnew+pnew->info.size; // Nouveau bloc sera après bloc où on a crée
    }
    pnew=pnew->info.ptr; // Pas trouvé, on passe au prochain
  }
  // Si on a pas eu assez de place, on va devoir agrandir mem allouée avec sbrk
  nb_sbrk++;
  pnew = sbrk(headerSize*101);
  pnew->info.size = headerSize*100;
  pnew->info.ptr = &base;
  //return malloc(size);
}


void myfree(void *ptr) {
  Header *ph = ptr - headerSize;
  Header *pprev = &base;
  while(pprev->info.ptr < ph) {
    pprev = pprev->info.ptr;
  }
  ph->info.ptr = pprev->info.ptr;
  // ***** Fusion avec les potentiels blocs libres suivants
  while(ph+ph->info.size+headerSize == ph->info.ptr) {
    ph->info.size += ph->info.ptr->info.size + headerSize;
    ph->info.ptr = ph->info.ptr->info.ptr;
  }
  // ***** Fin de la fusion
  pprev->info.ptr = ph;
  nb_dealloc += 1;
  //free(ptr);
}

void *mycalloc(size_t nmemb, size_t size) {
  //nb_alloc += 1;
  return mymalloc(nmemb*size);
  //return calloc(nmemb, size);
}

void *myrealloc(void *ptr, size_t size) {
  /* il faudrait probablement changer les valeur de nballoc et
   * nb_dealloc dans une véritable implémentation
   */
  if(ptr = NULL) { // avoir ptr NULL équivaut à avoir un malloc
    return mymalloc(size);
  }
  else if(size==0) { //  size 0 équivaut à avoir un free
    free(ptr);
  }
  else { // Si aucun de ces cas, on fait un realloc 'standard'
    Header *p = (Header*)ptr;
    p->info.size = size;
    return p;
  }
  //return realloc(ptr, size);
}

#ifdef MALLOC_DBG
void mymalloc_infos(char *msg) {
  if (msg) fprintf(stderr, "**********\n*** %s\n", msg);

  fprintf(stderr, "# allocs = %3d - # deallocs = %3d - # sbrk = %3d\n\n",
      nb_alloc, nb_dealloc, nb_sbrk);
  /* Ca pourrait être pas mal d'afficher ici les blocs dans la liste libre */
  // ******************** FAIT ICI ********************
  Header *pnew = &base;
  int i = 0;
  while(pnew->info.ptr!=&base) { // On cherche un bloc libre assez gros
    i++;
    fprintf(stderr, "=== Block No. %d ===\n", i);
    fprintf(stderr, "Current adress : %d\n", pnew);
    fprintf(stderr, "Next free block : %d\n", pnew->info.ptr);
    fprintf(stderr, "Block size : %d\n\n", pnew->info.size);
    pnew=pnew->info.ptr; // Pas trouvé, on passe au prochain
  }
  // ******************** FAIT ICI ********************

  if (msg) fprintf(stderr, "**********\n\n");
}
#endif