mecanismo malloc Análisis uClibc

uClibc dentro de los más utilizados c biblioteca lib. En un reciente estudio de la gestión de las cosas de memoria del núcleo Linux, después de la finalización de la gestión de la memoria ha sido el espacio de usuario muy confuso, para encontrar una parte especial del código en estudio malloc libc un poco, hay poca experiencia. Artículo especial resumió. Esta estructura de documento: a: Preparar Conocimiento II: Gestión estructura de espacio de almacenamiento dinámico de tres: inicializar espacio de almacenamiento dinámico de cuatro: la operación estructura FA Cinco: implementación de malloc de seis: implementación libre de siete: Resumen de: Preparar el conocimiento: el espacio de usuario, a menudo llama a malloc y la gestión de memoria libre, se asigna memoria en el espacio de almacenamiento dinámico del proceso. Como se muestra a continuación:

II: montón estructura de gestión de espacio: struct montón {//estructura de datos que muestra el espacio de montón estructura struct heap_free_area zona de libre * free_areas montón representación espacial; //para el bloqueo de la protección en un entorno multiproceso #ifdef bloqueo HEAP_USE_LOCKINGpthread_mutex_t; #endif}; heap_free_area FA se refiere a la estructura del código de la estructura del código. Se define de la siguiente manera: heap_free_area struct {//tamaño de la zona de libre size_t tamaño; //para la construcción de un heap_free_area lista de estructura circular * siguiente, * prev;}; Nota: en el FA en la estructura y no define un puntero a una zona libre, que ya que la estructura de la FA se coloca justo detrás de la zona de libre.

Tres: inicializar espacio de almacenamiento dinámico: variables globales __malloc_heap representan la totalidad del espacio de pila. Su proceso de inicialización se muestra como sigue: struct montón __malloc_heap = HEAP_INIT_WITH_FA (initial_fa); HEAP_INIT_WITH_FA definen como sigue: #ifdef HEAP_USE_LOCKING # define HEAP_INIT {0, PTHREAD_MUTEX_INITIALIZER} # definen HEAP_INIT_WITH_FA (fa) {&fa._fa, PTHREAD_MUTEX_INITIALIZER} # else # definir HEAP_INIT {0} # definir HEAP_INIT_WITH_FA (FA) {&fa._fa} #endif las variables inicializadas initial_fa de la siguiente manera: HEAP_DECLARE_STATIC_FREE_AREA (initial_fa, 256); # definir HEAP_DECLARE_STATIC_FREE_AREA (nombre, tamaño) \\ struct \\ estática {\\ espacio char [( tamaño) - sizeof (struct heap_free_area)]; \\ struct heap_free_area _FA; \\} name = {" ", {(tamaño), 0, 0}} por lo tanto se puede ver la inicialización montón es de 256 bytes. Puede verse en la inicialización anteriormente, la estructura estática delantera FA define un espacio de matriz. Esto también confirma la encima de dicho y " estructura FA coloca justo detrás de la zona de guardar y " cuatro: operación estructura FA: 1: #define HEAP_FREE_AREA_SIZE (fa) ((fa) - > tamaño) FA representada por el área libre de tamaño, que ya contiene la propia FA ocupar el espacio 2: HEAP_FREE_AREA_START #define (fa) ((void *) ((char *) (fa + 1) - (fa) - > tamaño)) FA de la zona de libre representado posición de partida. fa + 1 llega al final de la zona de libre. Y luego por el tamaño de la unidad del indicador, es la posición de inicio del área de repuesto 3: el extremo libre HEAP_FREE_AREA_END región #define (FA) ((void *) (FA + 1)) representado por la FA vuelve. A partir de la estructura representada por la FA se puede ver. El tamaño de un cambio de la FA dirección FA, simplemente llegar al final de libre de 4: (32 + sizeof (struct heap_free_area)) tamaño mínimo de la zona de libre #define HEAP_MIN_FREE_AREA_SIZE \\ HEAP_ADJUST_SIZE. área de reserva para ser capaz de mantener una heap_free_area tamaño mínimo, además de prescindir de 32 bytes, que es considerar la eficiencia. Cuando Malloc asignar memoria, ya veces se una FA se divide en dos secciones. Si la memoria restante es inferior a HEAP_MIN_FREE_AREA_SIZE., Así que podría ir toda la asignación de memoria. Debido a la necesidad de salvaguardar la memoria libre afecta la eficiencia. Esto se puede ver a partir de nuestro análisis de malloc y libre después en 5: __heap_delete (struct montón * montón, struct heap_free_area * fa) fa Esta función es eliminar del montón, su implementación es el siguiente: void__heap_delete línea extern (struct montón * heap , struct heap_free_area * fa) {if (fa- > siguiente) fa- > de próxima > prev = fa- > prev; si (fa- > prev) fa- > prev- > siguiente = fa - > siguiente; elseheap- > free_areas = fa- > siguiente; //si se elimina primero la lista de nodos} es una operación simple, el fa desconectado de la lista circular. 6: __heap_link_free_area (struct montón * montón, heap_free_area struct * fa, struct heap_free_area * prev, struct heap_free_area * siguiente) anotaciones de código desde el punto de vista de la función se refiere a la prev y próxima entre Fa fusionaron juntos. De hecho, es única en el medio anterior y al lado de inserción de una única. Para lograr lo siguiente: void__heap_link_free_area inline extern (struct montón * montón, struct heap_free_area * fa, struct heap_free_area * prev, heap_free_area struct * siguiente) {fa- > siguiente = próximo; fa- > prev = prev; si (prev) prev- > siguiente = fa; elseheap- > free_areas = fa; //nodo insertado como el nodo de entrada de la caja si (siguiente) de próxima > prev = fa;} 7: __ heap_link_free_area_after (struct montón * montón, struct heap_free_area * fa, struct heap_free_area prev *)