Jak działa malloc w środowisku wielowątkowym?

Question

Jak działa malloc w środowisku wielowątkowym?

Czy Typowy malloc (dla platformy x86-64 i systemu operacyjnego Linux) naiwnie blokuje mutex na początku i zwalnia go po zakończeniu, czy też blokuje mutex w bardziej sprytny sposób na drobniejszym poziomie, tak że blokada jest zmniejszona? Jeśli rzeczywiście robi to w drugą stronę, to jak to robi?

45

linux c malloc gcc x86-64

Author: Wladimir Palant, 2012-05-22

Source

2 answers

Doug Lea ' s malloc używane blokowanie zgrubne (lub bez blokowania, w zależności od ustawień konfiguracyjnych), gdzie każde wywołanie do malloc/realloc/free jest chroniony przez globalny mutex. Jest to bezpieczne, ale może być nieefektywne w środowiskach wielowątkowych.

ptmalloc3, jest to domyślna implementacja malloc w bibliotece GNU C (libc) używanej obecnie w większości systemów Linuksowych, ma bardziej drobnoziarnistą strategię, jak opisano w aix ' s answer, która pozwala na wiele wątki do jednoczesnej alokacji pamięci bezpiecznie.

nedmalloc jest kolejną niezależną implementacją, która twierdzi, że wydajność wielowątkowa jest jeszcze lepsza niż ptmalloc3 i różne inne alokatory. Nie wiem, jak to działa, i nie wydaje się być żadnej oczywistej dokumentacji, więc będziesz musiał sprawdzić kod źródłowy, aby zobaczyć, jak to działa.

19

Author: Adam Rosenfield,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-05-23 12:33:42

score 36 · Accepted Answer

glibc 2.15 obsługuje wiele Aren alokacji . Każda arena ma swój własny zamek. Gdy wątek musi przydzielić pamięć, malloc() wybiera arenę, blokuje ją i przydziela z niej pamięć.

Mechanizm wyboru areny jest nieco rozbudowany i ma na celu zmniejszenie blokady:]}

/* 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. */

Mając to na uwadze, malloc() w zasadzie wygląda to tak (edytowane dla zwięzłości):

  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;

Ten alokator nazywa się ptmalloc. Opiera się na wcześniejszej pracy by Doug Lea i jest utrzymywany przez Wolframa Glogera.