Implementación de un memory pool

En aplicaciones en las que se reserva y libera memoria con mucha frecuencia se puede sufrir fragmentación de memoria. Cuando el rendimiento no es demasiado importante este comportamiento puede ser aceptable, en cambio, si esto se produce en una aplicación de tiempo real es necesario solucionarlo.

Para evitar la fragmentación de memoria existe una técnica llamada memory pool, básicamente consiste en crear un espacio fijo de memoria para que la aplicación lo administe.

En el siguiente ejemplo se crea un pool para un conjunto de threads que lo comparten.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

#define BUF_SIZE 128
#define POOL_SIZE 36
#define NUM_THREADS 10

typedef struct dataStruct{
 int id;
 char cadena[BUF_SIZE];
} data;


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

data **dataPool;
int next_data = 0;

int get_next_memory_position(){
 pthread_mutex_lock(&mutex); 
 next_data = (next_data + 1) % POOL_SIZE;
 pthread_mutex_unlock(&mutex);
 return next_data;
}

data **allocate_pool(){
 int i; 
 data **d = (data**) malloc(sizeof(data*) * POOL_SIZE);
 
 for(i = 0;i < POOL_SIZE; i++){
  d[i] = malloc(sizeof(data));
 }
 
 return d;
}

void *thread(){
 data *param = dataPool[get_next_memory_position()];
 
 param->id = next_data;
 strcpy(param->cadena, "hello");
 
 printf("%d: %s \n", param->id, param->cadena);
}

int main(){
 pthread_t t[NUM_THREADS];
 dataPool = allocate_pool();
 int i;
 
 for(i = 0;i < NUM_THREADS; i++){
  pthread_create(&t[i], NULL, thread, NULL);
 }

 for(i = 0;i < NUM_THREADS; i++){
  pthread_join(t[i], NULL);
 }
}

En este ejemplo se asigna automáticamente memoria a los threads conforme la piden circularmente, este planteamiento no vale siempre, para cambiar la política de asignación de bloques libres solo hay que cambiar el método get_next_memory_position.