_C_Quickpool_Init ()- Inicializar gestor de memoria de agrupación rápida

Formato

#include <stdlib.h>
int _C_Quickpool_Init(unsigned int numpools, unsigned int *cell_sizes, unsigned int *num_cells);

Nivel de idioma

Ampliada

De hebra segura

Sí

Descripción

Cuando se llama a la función _C_Quickpool_Init() , todas las llamadas posteriores a las funciones del gestor de memoria (malloc, calloc, reallocy free) del mismo grupo de activación utilizan el gestor de memoria de agrupación rápida. Este gestor de memoria proporciona un rendimiento mejorado para algunas aplicaciones.

El gestor de memoria de agrupación rápida divide la memoria en una serie de agrupaciones. Cada agrupación se divide en un número de celdas con tamaños idénticos. El número de agrupaciones, el tamaño de las células de cada agrupación y el número de células de cada extensión de agrupación se establecen utilizando la función _C_Quickpool_Init() . Las variables de entorno también se pueden utilizar para configurar este soporte (sección de referencia Variables de entorno).

Supongamos que un usuario desea definir cuatro agrupaciones, cada una de las cuales contiene 64 células. La primera agrupación tendrá celdas con un tamaño de 16 bytes; la segunda agrupación tendrá celdas con un tamaño de 256 bytes; la tercera agrupación tendrá celdas con un tamaño de 1024 bytes; y la cuarta agrupación tendrá celdas con un tamaño de 2048 bytes. Cuando se realiza una solicitud de almacenamiento, el gestor de memoria asigna primero la solicitud a una agrupación. El gestor de memoria compara el tamaño de almacenamiento de la solicitud con el tamaño de las células de una agrupación determinada.

En este ejemplo, la primera agrupación satisface solicitudes entre 1 y 16 bytes de tamaño; la segunda agrupación satisface solicitudes entre 17 y 256 bytes de tamaño; la tercera agrupación satisface solicitudes entre 257 y 1024 bytes de tamaño, y la cuarta agrupación satisface solicitudes entre 1025 y 2048 bytes de tamaño. Las solicitudes mayores que el tamaño de celda más grande se asignan a través del gestor de memoria por omisión.

Una vez asignada la agrupación, se examina la cola libre de la agrupación. Cada agrupación tiene una cola libre que contiene células que se han liberado y que todavía no se han reasignado. Si hay una célula en la cola libre, la célula se elimina de la cola libre y se devuelve; de lo contrario, la célula se recupera de la extensión actual para la agrupación. Una extensión es una colección de celdas que se asignan como un bloque. Inicialmente, una agrupación no tiene extensiones.

Cuando entra la primera solicitud para una agrupación, se asigna una extensión para la agrupación y la solicitud se satisface desde esa extensión. Las solicitudes posteriores para la agrupación también se satisfacen por esa extensión hasta que se agota la extensión. Cuando se agota una extensión, se asigna una nueva extensión para la agrupación. Si no se puede asignar una nueva extensión, se presupone que existe un problema de memoria. Se intentará asignar el almacenamiento utilizando el gestor de memoria por omisión. Si el intento no es satisfactorio, se devuelve el valor NULL.

númagrupaciones
El número de agrupaciones a utilizar para el gestor de memoria de agrupación rápida. Este parámetro puede tener un valor entre 1 y 64.
tamaños de celda
Matriz de valores enteros sin signo. El número de entradas de la matriz es igual al número especificado en el parámetro numpools. Cada entrada especifica el número de bytes de una célula para una agrupación determinada. Estos valores deben ser múltiplos de 16 bytes. Si se especifica un valor que no es un múltiplo de 16 bytes, el tamaño de celda se redondea al siguiente múltiplo mayor de 16 bytes. El valor mínimo válido es de 16 bytes y el valor máximo válido es de 4096 bytes.
núm_celdas
Matriz de valores enteros sin signo. El número de entradas de la matriz es igual al número especificado en el parámetro numpools. Cada entrada especifica el número de celdas en una sola extensión para la agrupación correspondiente. Cada valor puede ser cualquier número no negativo, pero el tamaño total de cada extensión puede estar limitado debido a restricciones de arquitectura. Un valor de cero indica que la implementación debe elegir un valor grande.

A continuación se muestra la llamada a _C_Quickpool_Init() para el ejemplo anterior:

unsigned int cell_sizes[4] = { 16, 256, 1024, 2048 };
unsigned int cells_per_extent[4] = { 64, 64, 64, 64 };
rc = _C_Quickpool_Init(4,                       /* number of pools            */
                       cell_sizes,              /* cell sizes for each pool   */
                       cells_per_extent);       /* extent sizes for each pool */

Valor de retorno

La lista siguiente muestra los valores de retorno para la función _C_Quickpool_Init() :
0
Correcto
-1
Ya se ha habilitado un gestor de memoria alternativo para este grupo de activación.
-2
Error al asignar almacenamiento para estructuras de control.
-3
Se ha especificado un número no válido de agrupaciones.
-4
Se ha llamado a _C_Quickpool_Init() desde un grupo de activación no válido.
-5
Se ha producido una excepción inesperada al ejecutar _C_Quickpool_Init() .

Ejemplo

El ejemplo siguiente utiliza _C_Quickpool_Init() para habilitar la asignación de memoria de agrupación rápida.
#include <stdlib.h>
#include <stdio.h>
int main(void) {
  char *p;
  unsigned int cell_sizes[2]       = { 16, 64 };
  unsigned int cells_per_extent[2] = { 16, 16 };

  if (_C_Quickpool_Init(2, cell_sizes, cells_per_extent) {
    printf("Error initializing Quick Pool memory manager.\n");
    return -1;
  }
  if ((p = malloc(10)) == NULL) {
    printf("Error during malloc.\n");
    return -2;
  }
  free(p);
  printf("Test successful!\n");
  return 0;
}
/*****************Output should be similar to:*****************
Test successful!
*******************************************************************/

Información relacionada