Gustavo Sied > Sin categoría > Pool de memoria simple de implementación para aplicaciones en tiempo real
Pool de memoria simple de implementación para aplicaciones en tiempo real
Gustavo
4 febrero, 2014
Queridos lectores,
En este post, me gustaría presentar sobre el simple Implementación piscina de memoria que se puede utilizar para aplicaciones en tiempo real.
Antes de mirar a la implementación real, primero saber acerca de lo que es la agrupación de memoria y por qué se requiere en aplicaciones en tiempo real
En aplicaciones en tiempo real, el rendimiento juega un papel muy importante. Eso significa que cualquier sistema de tiempo real debe tener un alto rendimiento para obtener resultados deseables de lo contrario se considera como sistema inútil.
Por lo tanto, cuando cada vez que un desarrollador de escribir código, él / ella debe tener en cuenta que la cantidad de optimización de código y el rendimiento que se va a lograr con la aplicación
En el código menudo los desarrolladores asignan la memoria mediante macros de asignación dinámica como MALLOC en
caso de C y NUEVO en el caso de C + +
Supongamos, usted tiene el sistema receptor de paquetes que recibe los paquetes desde otro dispositivo. Y esta responsabilidad del sistema receptor para agregar un encabezado adicional para el paquete recibido y envía el paquete modificado hacia el dispositivo final.
¿Qué sucede cuando el código asigna / dellocates memoria mediante malloc / free para cada paquete
¿Crees que hay una degradación del rendimiento? Sí, es obvio que hay una degradación del rendimiento.
Entonces, ¿qué es la solución? La solución es piscinas memoria
Una solución más eficiente es preasignación un número de bloques de memoria con el mismo tamaño de la llama ; bloque de memoria . La aplicación puede asignar, acceso y bloques libres representados por a en tiempo de ejecución
.
de memoria es de pre-asignación de tamaño fijo de memoria o también definido como tamaño fijo de memoria asignada utilizando MALLOC o Nueva durante la inicialización del sistema
<. div style = "text-align: justify;">
Para evitar la degradación del rendimiento de los sistemas de tiempo real.
¿Cómo se implementa?
Paso 1: Crear un banco de memoria
plicación necesita para inicializar una piscina. Aplicación asigna la memoria requerida durante el tiempo de inicialización utilizando MALLOC / NUEVO.
Siempre que se requiera una memoria y la misma memoria se trajo de la piscina.
Paso 3: Agregue memoria a la piscina
Una vez que la memoria ya no se utiliza a continuación, añadir la misma memoria de la piscina
<. div style = "text-align: justify;"> Paso 4: Destruye la memoria / Desasignar piscina
Y, por último, antes de se cierra la aplicación, se debe desasignar la piscina, para asegurarse de que todos los bloques de memoria asignados por la fábrica son liberados de nuevo al sistema operativo. Después de esto, por supuesto, no más la asignación de bloque de memoria se puede solicitar.
programa simple para Piscina Memoria:
# include
# include
# include
# define MAX_MEMORY_POOL_NODES 10
/ * Nodo * /
typedef struct nodo
{
datos int;
int nodeAllocated;
} NODO;
typedef struct Memorypool
{
NODO * array [MAX_MEMORY_POOL_NODES];
int nodeCounter;
} MEMORYPOOL;
MEMORYPOOL allocNode;
/ *
* initialiseMemoryPool ()
* /
vacío initialiseMemoryPool ()
{
uIndx unsigned char;
/ * Inicialización de la memoria para los nodos * /
for (uIndx = 0; uIndx
{
allocNode.array [uIndx] = (NODO *) malloc (sizeof (NODO));
allocNode.array [uIndx] -> ; nodeAllocated = 0;
allocNode.nodeCounter + +;
}
}
NODO * getTheFreeNodeFromPool ()
{
int uIndx;
/ * Obtener la memoria del grupo de nodos * /
para (uIndx = 0; uIndx
{
if (allocNode.array [uIndx] -> nodeAllocated == 0)
{
allocNode.array [uIndx] -> nodeAllocated = 1;
; allocNode.nodeCounter–;
romper;
}
}
if (uIndx == MAX_MEMORY_POOL_NODES)
{
printf (» No hay nodos libres están disponibles n » );
devuelve NULL;
}
volver allocNode.array [uIndx ];
}
/ *
* Añadir el nodo a la piscina Memory
* /
vacío addTheNodeToMemoryPool (uIndx unsigned char)
{
/ * Añadir el nodo a la piscina * /
if (allocNode.array [uIndx] -> nodeAllocated == 1)
{
allocNode.array [uIndx] -> data = 0;
allocNode.array [uIndx] -> nodeAllocated = 0;
allocNode.nodeCounter + +;
}
demás
{
printf (» No hay nodos están ahí Añadir n «);
volver;
}
}
/ *
* deallocateTheMemoryPool-Desasignar la piscina Memory
* /
vacío deallocateTheMemoryPool (void)
{
uIndx unsigned carbón;
/ * De-asignar la memoria de billar * /
, pues (uIndx = 0; uIndx
{
Courier style=»font-family: libre (allocNode.array [uIndx]);
}
}
/ * Inicio * /
int main ()
{
uIndx unsigned char, índice;
Courier style=»font-family: / / Paso 1:
/ * Inicializar la agrupación de memoria * /
initialiseMemoryPool ();
/ / Paso 2:
/ * Obtener el nodo en el agrupación de memoria * /
para (uIndx = 0; uIndx
{
NODO * nodo = NULL;
; datos int;
= nodo getTheFreeNodeFromPool ();
if (nodo)
{
; printf («Introduzca los datos que se añadirán en la Lista de enlaces n»);
scanf («% d», & datos);
-> nodo data = datos;
}
}
/ * mostrar los datos * /
printf (» Display Data n «);
para (uIndx = 0; uIndx
{
printf («% d n», allocNode.array [uIndx] -> data);
}
/ / Paso 3:
/ * Añadir el nodo de agrupación de memoria * /
printf (» Introduzca el nodo que se añade a la agrupación de memoria n «);
scanf («% d «, & index);
;
addTheNodeToMemoryPool (índice);
/ * mostrar los datos * /
printf («Mostrar datos después de la adición de nodos a libre piscina n»);
para (uIndx = 0; uIndx
{
printf («% d n», allocNode.array [uIndx] -> data);
;}
/ / Paso 4:
/ * De Asignar la agrupación de memoria * /
deallocateTheMemoryPool ();
return 0;
Courier style=»font-family: }
