/* Allocateur base sur la constitution d'une liste chaine de bloc pointee */
/* par debutListe                                                         */

/*********************************************
Explications liees au fonctionnement bugge du programme bug.c

a. Quelle est l'origine du bug ?
La constante CHAINE de bug.c fait 16 caracteres. Elle occupe donc 17 octets en 
memoire avec le '\0' final. De ce fait, quand on affecte CHAINE a s1, le '\0' 
de s1 deborde sur le premier octet de s2. s2 se retrouve donc avec la 
valeur "".

b. Pour quelle raison valgrind applique au programme bug ne detecte rien ?
Valgrind ne detecte rien, car toutes ces operations se deroulent dans une 
zone memoire de NBMAXALLOC*TAILLEBLOC=48 octets alloues au moment de 
l'execution de monAllocateurInit(). Donc, nous ne depassons pas les bornes 
de cette zone memoire. NB : si vous mettez 2 comme valeur de NBMAXALLOC et 
que vous recompilez, valgrind detecte le problème des le strcpy sur s2 !

c. Quelle fonction utilisee en lieu et place de strcpy aurait évite ce bug ?
L'utilisation de strncpy(s1s2, CHAINE, TAILLEBLOC) nous aurait evite ce bug.

d. Complétez les informations suivantes :
- Type machine utilisée (si vous le connaissez) : Dell Precision T3500
- Processeur et fréquence (si vous les connaissez) : processeur Intel Xeon W3530 (2.80 GHz)
- Taille RAM (si vous la connaissez) : 4 GiB
- Système d'exploitation (uname -a) : Linux 3.14.9 SMP
- Synthèse des résultats :

                        +-------------------------+-------------------------------+--------------------+
                        | par appel a malloc/free | par appel a monMalloc/monFree | Reduction du temps |
                        |     (nanosecondes)      |         (nanosecondes)        |    (pourcentage)   |
+-----------------------+-------------------------+-------------------------------+--------------------+
| Allocation mémoire    |             11 us       |                     2 us      |          -82 %     |    
+-----------------------+-------------------------+-------------------------------+--------------------+
| Désallocation mémoire |              9 us       |                     1 us      |          -89 %     |
+-----------------------+-------------------------+-------------------------------+--------------------+

*********************************************/


#include <stdlib.h>
#include <assert.h>
#include "monAllocateur.h"

typedef struct Bloc {
  struct Bloc* suivant;
  char remplissage[TAILLEBLOC-sizeof(struct Bloc*)];
} Bloc;

static Bloc *debutListe;

/**************************************************************************/
/* Routine d'initialisation de l'allocateur : constitue une liste chainee */
/* de nbMaxAlloc blocs de taille TAILLEBLOC, le premier bloc etant pointe */
/* par debutListe et le dernier pointant sur NULL                         */
/**************************************************************************/
void monAllocateurInit(int nbMaxAlloc)
{
  Bloc *ptr;
  int i;

  /* ATTENTION : vous n'avez droit de faire qu'un seul malloc de */
  /*             nbMaxAlloc*TAILLEBLOC ou bien un calloc !       */
  /* On alloue un unique bloc avec calloc. On y decoupera nos blocs */
  ptr = calloc(nbMaxAlloc,TAILLEBLOC);
  assert(ptr != 0);

  /* Memorisation du debut de la liste chainee */
  debutListe = ptr;

  /* Decoupage du bloc retourne par malloc en nbMaxBloc constituant une liste*/
  /* chainee                                                                 */
  for (i=0 ; i<(nbMaxAlloc-1) ; i++) {
    ptr[i].suivant = &ptr[i+1];
  }

  /* Le dernier bloc a son pointeur a NULL */
  ptr[i].suivant = NULL;
}

/**************************************************************************/
/* Fonction renvoyant un pointeur sur une zone memoire                    */
/* NB : on ne peut pas preciser la taille, puisque la taille est          */
/*      predefinie                                                        */
/**************************************************************************/
void *monMalloc(void)
{
  Bloc *ptr;

  assert(debutListe != NULL);

  ptr = debutListe;
  debutListe = debutListe->suivant;

  return (void *)ptr;
}

/**************************************************************************/
/* Fonction liberant la zone memoire pointee par ptr                      */
/**************************************************************************/
void monFree(void *ptr)
{
  Bloc *pBloc = (Bloc*)ptr;
  pBloc->suivant = debutListe;
  debutListe = pBloc;
}