contrib/jemalloc/src/mutex.c

   1 #define JEMALLOC_MUTEX_C_
   2 #include "jemalloc/internal/jemalloc_internal.h"
   3
   4 #if defined(JEMALLOC_LAZY_LOCK) && !defined(_WIN32)
   5 #include <dlfcn.h>
   6 #endif
   7
   8 #ifndef _CRT_SPINCOUNT
   9 #define _CRT_SPINCOUNT 4000
  10 #endif
  11
  12 /******************************************************************************/
  13 /* Data. */
  14
  15 #ifdef JEMALLOC_LAZY_LOCK
  16 bool isthreaded = false;
  17 #endif
  18 #ifdef JEMALLOC_MUTEX_INIT_CB
  19 static bool             postpone_init = true;
  20 static malloc_mutex_t   *postponed_mutexes = NULL;
  21 #endif
  22
  23 #if defined(JEMALLOC_LAZY_LOCK) && !defined(_WIN32)
  24 static void     pthread_create_once(void);
  25 #endif
  26
  27 /******************************************************************************/
  28 /*
  29  * We intercept pthread_create() calls in order to toggle isthreaded if the
  30  * process goes multi-threaded.
  31  */
  32
  33 #if defined(JEMALLOC_LAZY_LOCK) && !defined(_WIN32)
  34 static int (*pthread_create_fptr)(pthread_t *__restrict, const pthread_attr_t *,
  35     void *(*)(void *), void *__restrict);
  36
  37 static void
  38 pthread_create_once(void)
  39 {
  40
  41         pthread_create_fptr = dlsym(RTLD_NEXT, "pthread_create");
  42         if (pthread_create_fptr == NULL) {
  43                 malloc_write("<jemalloc>: Error in dlsym(RTLD_NEXT, "
  44                     "\"pthread_create\")\n");
  45                 abort();
  46         }
  47
  48         isthreaded = true;
  49 }
  50
  51 JEMALLOC_EXPORT int
  52 pthread_create(pthread_t *__restrict thread,
  53     const pthread_attr_t *__restrict attr, void *(*start_routine)(void *),
  54     void *__restrict arg)
  55 {
  56         static pthread_once_t once_control = PTHREAD_ONCE_INIT;
  57
  58         pthread_once(&once_control, pthread_create_once);
  59
  60         return (pthread_create_fptr(thread, attr, start_routine, arg));
  61 }
  62 #endif
  63
  64 /******************************************************************************/
  65
  66 #ifdef JEMALLOC_MUTEX_INIT_CB
  67 JEMALLOC_EXPORT int     _pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,
  68     void *(calloc_cb)(size_t, size_t));
  69
  70 #pragma weak _pthread_mutex_init_calloc_cb
  71 int
  72 _pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,
  73     void *(calloc_cb)(size_t, size_t))
  74 {
  75
  76         return (((int (*)(pthread_mutex_t *, void *(*)(size_t, size_t)))
  77             __libc_interposing[INTERPOS__pthread_mutex_init_calloc_cb])(mutex,
  78             calloc_cb));
  79 }
  80 #endif
  81
  82 bool
  83 malloc_mutex_init(malloc_mutex_t *mutex, const char *name, witness_rank_t rank)
  84 {
  85
  86 #ifdef _WIN32
  87 #  if _WIN32_WINNT >= 0x0600
  88         InitializeSRWLock(&mutex->lock);
  89 #  else
  90         if (!InitializeCriticalSectionAndSpinCount(&mutex->lock,
  91             _CRT_SPINCOUNT))
  92                 return (true);
  93 #  endif
  94 #elif (defined(JEMALLOC_OSSPIN))
  95         mutex->lock = 0;
  96 #elif (defined(JEMALLOC_MUTEX_INIT_CB))
  97         if (postpone_init) {
  98                 mutex->postponed_next = postponed_mutexes;
  99                 postponed_mutexes = mutex;
 100         } else {
 101                 if (_pthread_mutex_init_calloc_cb(&mutex->lock,
 102                     bootstrap_calloc) != 0)
 103                         return (true);
 104         }
 105 #else
 106         pthread_mutexattr_t attr;
 107
 108         if (pthread_mutexattr_init(&attr) != 0)
 109                 return (true);
 110         pthread_mutexattr_settype(&attr, MALLOC_MUTEX_TYPE);
 111         if (pthread_mutex_init(&mutex->lock, &attr) != 0) {
 112                 pthread_mutexattr_destroy(&attr);
 113                 return (true);
 114         }
 115         pthread_mutexattr_destroy(&attr);
 116 #endif
 117         if (config_debug)
 118                 witness_init(&mutex->witness, name, rank, NULL);
 119         return (false);
 120 }
 121
 122 void
 123 malloc_mutex_prefork(tsdn_t *tsdn, malloc_mutex_t *mutex)
 124 {
 125
 126         malloc_mutex_lock(tsdn, mutex);
 127 }
 128
 129 void
 130 malloc_mutex_postfork_parent(tsdn_t *tsdn, malloc_mutex_t *mutex)
 131 {
 132
 133         malloc_mutex_unlock(tsdn, mutex);
 134 }
 135
 136 void
 137 malloc_mutex_postfork_child(tsdn_t *tsdn, malloc_mutex_t *mutex)
 138 {
 139
 140 #ifdef JEMALLOC_MUTEX_INIT_CB
 141         malloc_mutex_unlock(tsdn, mutex);
 142 #else
 143         if (malloc_mutex_init(mutex, mutex->witness.name,
 144             mutex->witness.rank)) {
 145                 malloc_printf("<jemalloc>: Error re-initializing mutex in "
 146                     "child\n");
 147                 if (opt_abort)
 148                         abort();
 149         }
 150 #endif
 151 }
 152
 153 bool
 154 malloc_mutex_first_thread(void)
 155 {
 156
 157 #ifdef JEMALLOC_MUTEX_INIT_CB
 158         postpone_init = false;
 159         while (postponed_mutexes != NULL) {
 160                 if (_pthread_mutex_init_calloc_cb(&postponed_mutexes->lock,
 161                     bootstrap_calloc) != 0)
 162                         return (true);
 163                 postponed_mutexes = postponed_mutexes->postponed_next;
 164         }
 165 #endif
 166         return (false);
 167 }
 168
 169 bool
 170 malloc_mutex_boot(void)
 171 {
 172
 173 #ifndef JEMALLOC_MUTEX_INIT_CB
 174         return (malloc_mutex_first_thread());
 175 #else
 176         return (false);
 177 #endif
 178 }