usar - memoria dinamica en c ejemplos

¿Cómo funciona malloc en un entorno multiproceso?

Question

¿El típico malloc (para la plataforma x86-64 y el sistema operativo Linux) bloquea ingenuamente un mutex al principio y lo libera cuando termina, o bloquea un mutex de una manera más inteligente en un nivel más fino, de modo que se reduce la contención del bloqueo? Si de hecho lo hace de la segunda manera, ¿cómo lo hace?

Answer 1

El malloc Doug Lea usó el bloqueo grueso (o sin bloqueo, según las configuraciones), donde cada llamada a malloc / realloc / free está protegida por un mutex global. Esto es seguro pero puede ser ineficiente en entornos altamente multiproceso.

ptmalloc3 , que es la implementación predeterminada de malloc en la biblioteca C de GNU (libc) utilizada en la mayoría de los sistemas Linux en la ptmalloc3 , tiene una estrategia más precisa, como se describe en la respuesta de Aix , que permite que varios subprocesos asignen simultáneamente memoria de forma segura.

nedmalloc es otra implementación independiente que asegura un rendimiento de subprocesos aún mejor que ptmalloc3 y varios otros asignadores. No sé cómo funciona, y no parece haber ninguna documentación obvia, por lo que tendrá que verificar el código fuente para ver cómo funciona.

Answer 2

glibc 2.15 opera múltiples arenas de asignación. Cada arena tiene su propio candado. Cuando un subproceso necesita asignar memoria, malloc() elige una arena, la bloquea y asigna memoria desde allí.

El mecanismo para elegir una arena es algo elaborado y tiene como objetivo reducir la contención de bloqueo:

/* arena_get() acquires an arena and locks the corresponding mutex.
   First, try the one last locked successfully by this thread.  (This
   is the common case and handled with a macro for speed.)  Then, loop
   once over the circularly linked list of arenas.  If no arena is
   readily available, create a new one.  In this latter case, `size''
   is just a hint as to how much memory will be required immediately
   in the new arena. */

Con esto en mente, malloc() básicamente se ve así (editado por brevedad):

  mstate ar_ptr;
  void *victim;

  arena_lookup(ar_ptr);
  arena_lock(ar_ptr, bytes);
  if(!ar_ptr)
    return 0;
  victim = _int_malloc(ar_ptr, bytes);
  if(!victim) {
    /* Maybe the failure is due to running out of mmapped areas. */
    if(ar_ptr != &main_arena) {
      (void)mutex_unlock(&ar_ptr->mutex);
      ar_ptr = &main_arena;
      (void)mutex_lock(&ar_ptr->mutex);
      victim = _int_malloc(ar_ptr, bytes);
      (void)mutex_unlock(&ar_ptr->mutex);
    } else {
      /* ... or sbrk() has failed and there is still a chance to mmap() */
      ar_ptr = arena_get2(ar_ptr->next ? ar_ptr : 0, bytes);
      (void)mutex_unlock(&main_arena.mutex);
      if(ar_ptr) {
        victim = _int_malloc(ar_ptr, bytes);
        (void)mutex_unlock(&ar_ptr->mutex);
      }
    }
  } else
    (void)mutex_unlock(&ar_ptr->mutex);

  return victim;

Este asignador se llama ptmalloc . Se basa en el trabajo anterior de Doug Lea, y es mantenido por Wolfram Gloger.