¿Cuál es la diferencia entre xmalloc y malloc?

¿Cuál es la diferencia entre xmalloc() y malloc() para la asignación de memoria?
¿Hay algún profesional de usar xmalloc() ?

xmalloc() es una función no estándar que tiene el lema éxito o muerte . Si no puede asignar memoria, terminará su progtwig e imprimirá un mensaje de error a stderr .

La asignación en sí no es diferente; solo el comportamiento en el caso de que no se pueda asignar memoria es diferente.

Usa malloc() , ya que es más amigable y estándar.

xmalloc no es parte de la biblioteca estándar. Por lo general, es el nombre de una función muy dañina para los progtwigdores perezosos que es común en muchos progtwigs GNU, que abort si falla malloc . Dependiendo del progtwig / biblioteca, también puede convertir malloc(0) en malloc(1) para asegurar que xmalloc(0) devuelva un puntero único.

En cualquier caso, abort en una falla de malloc es un comportamiento muy malo, especialmente para el código de la biblioteca. Uno de los ejemplos más infames es GMP (la biblioteca aritmética de multiprecisión de GNU), que anula el progtwig de llamada siempre que se queda sin memoria para un cálculo.

El código correcto a nivel de biblioteca siempre debe manejar los fallos de asignación al anular cualquier operación parcialmente completada en la que se encontraba en medio y devolver un código de error a la persona que llama. El progtwig de llamada puede decidir qué hacer, lo que probablemente implique guardar datos críticos.

Como han mencionado otros, es cierto que xmalloc se implementa muy a menudo como una función de envoltorio que invoca el malloc proporcionado por el sistema operativo y llama ciegamente abort o exit si falla. Sin embargo, muchos proyectos contienen una función xmalloc que intenta guardar el estado de la aplicación antes de salir (consulte, por ejemplo, neovim ).

Personalmente, considero a xmalloc como un tipo de malloc extendido específico del proyecto en lugar de un malloc saliente . Aunque no recuerdo haber visto una versión que no terminara por abort o exit , algunos de ellos hacen mucho más que eso.

Entonces, la respuesta a la pregunta “¿Cuál es la diferencia entre xmalloc y malloc es: depende. xmalloc es una función específica del proyecto, por lo que podría hacer cualquier cosa. La única forma de saberlo con seguridad es leer el código.

un ejemplo primitivo de xmalloc.c en K&R C

 #include  extern char *malloc (); void * xmalloc (size) unsigned size; { void *new_mem = (void *) malloc (size); if (new_mem == NULL) { fprintf (stderr, "fatal: memory exhausted (xmalloc of %u bytes).\n", size); exit (-1); } return new_mem; } 

Luego en el encabezado de tu código (temprano) pones

#define malloc(m) xmalloc(m)

para volver a escribir la fuente en silencio antes de la comstackción. (Puede ver el código reescrito invocando directamente al preprocesador de C y guardando la salida).

Si bloquear su progtwig no es lo que quiere, puede hacer algo diferente.

  • Usa un recolector de basura
  • rediseña tu código para que sea menos de un montón de memoria
  • tiene un código de verificación de errores en su progtwig para manejar sin gracia un error de memoria u otro error de asignación.

Los usuarios no disfrutan perdiendo sus datos ante un comando incorporado de locking en su progtwig.

xmalloc es parte de libiberty

https://gcc.gnu.org/onlinedocs/libiberty/index.html que es una biblioteca de utils de GNU.

malloc es ANSI C.

xmalloc se incluye a menudo en la fuente en muchos proyectos importantes de GNU, incluidos GCC y Binutils, que lo utilizan mucho. Pero también es posible construirlo como una biblioteca dinámica para usar en sus progtwigs. Por ejemplo, Ubuntu tiene el paquete libiberty-dev .

xmalloc está documentado en: https://gcc.gnu.org/onlinedocs/libiberty/Functions.html y en GCC 5.2.0 se implementa en libiberty / xmalloc.c

 PTR xmalloc (size_t size) { PTR newmem; if (size == 0) size = 1; newmem = malloc (size); if (!newmem) xmalloc_failed (size); return (newmem); } void xmalloc_failed (size_t size) { #ifdef HAVE_SBRK extern char **environ; size_t allocated; if (first_break != NULL) allocated = (char *) sbrk (0) - first_break; else allocated = (char *) sbrk (0) - (char *) &environ; fprintf (stderr, "\n%s%sout of memory allocating %lu bytes after a total of %lu bytes\n", name, *name ? ": " : "", (unsigned long) size, (unsigned long) allocated); #else /* HAVE_SBRK */ fprintf (stderr, "\n%s%sout of memory allocating %lu bytes\n", name, *name ? ": " : "", (unsigned long) size); #endif /* HAVE_SBRK */ xexit (1); } /* This variable is set by xatexit if it is called. This way, xmalloc doesn't drag xatexit into the link. */ void (*_xexit_cleanup) (void); void xexit (int code) { if (_xexit_cleanup != NULL) (*_xexit_cleanup) (); exit (code); } 

Lo que, como otros han mencionado, es bastante sencillo:

  • prueba malloc
  • si falla
    • imprimir mensajes de error
    • exit llamada

He visto xmalloc mientras trabajaba en IBM AIX. xmalloc es un servicio de kernel proporcionado por AIX.

Nada puede explicar una función mejor que la página de manual de la función en mi opinión. Así que estoy pegando los detalles de abajo de la página del manual

Propósito: Asigna memoria.

Sintaxis:

caddr_t xmalloc (tamaño, alineación, almacenamiento dynamic)

Parámetros:

tamaño: especifica el número de bytes para asignar.

alinear: especifica las características de alineación para la memoria asignada.

montón: especifica la dirección del montón desde el que se asignará la memoria.

Descripción:

El servicio del kernel xmalloc asigna un área de memoria fuera del montón especificado por el parámetro de montón. Esta área es el número de bytes en longitud especificada por el parámetro de tamaño y se alinea en el límite de byte especificado por el parámetro alinear. El parámetro de alineación es en realidad la base de registro 2 del límite de dirección deseado. Por ejemplo, un valor de alineación de 4 solicita que el área asignada se alinee en un límite de 2 ^ 4 (16) bytes.

Existen múltiples montones proporcionados por el kernel para ser usados ​​por las extensiones del kernel. Dos stacks primarias del núcleo son kernel_heap y pinned_heap. Las extensiones del kernel deben usar el valor kernel_heap al asignar memoria que no está anclada, y deben usar el valor pinned_heap cuando se asigna memoria que siempre debe estar anclada o fijada por largos períodos de tiempo. Cuando se asigna desde el montón pinned_heap, el servicio del núcleo xmalloc fijará la memoria antes de una devolución exitosa. Los servicios de kernel pin y unpin se deben usar para pinchar y desasignar la memoria de la stack kernel_heap cuando la memoria solo se debe pinchar durante un período de tiempo limitado. La memoria de la stack de kernel_heap debe estar desactivada antes de liberarla. La memoria del montón de Pinned_heap no debe ser no clavada.

Si alguien está interesado en saber más sobre esta función, puede visitar el siguiente enlace: Soporte de IBM AIX