Redis 2.6.5

[redis.git] / deps / jemalloc / src / mutex.c

diff --git a/deps/jemalloc/src/mutex.c b/deps/jemalloc/src/mutex.c
index ca89ef1c9627f198293062124fae31bc426d8ec2..37a843e6e44e717e9c53af400fa5e54d58132fd9 100644 (file)
--- a/deps/jemalloc/src/mutex.c
+++ b/deps/jemalloc/src/mutex.c
@@ -1,14 +1,26 @@
 #define        JEMALLOC_MUTEX_C_
 #include "jemalloc/internal/jemalloc_internal.h"
 
+#if defined(JEMALLOC_LAZY_LOCK) && !defined(_WIN32)
+#include <dlfcn.h>
+#endif
+
+#ifndef _CRT_SPINCOUNT
+#define _CRT_SPINCOUNT 4000
+#endif
+
 /******************************************************************************/
 /* Data. */
 
 #ifdef JEMALLOC_LAZY_LOCK
 bool isthreaded = false;
 #endif
+#ifdef JEMALLOC_MUTEX_INIT_CB
+static bool            postpone_init = true;
+static malloc_mutex_t  *postponed_mutexes = NULL;
+#endif
 
-#ifdef JEMALLOC_LAZY_LOCK
+#if defined(JEMALLOC_LAZY_LOCK) && !defined(_WIN32)
 static void    pthread_create_once(void);
 #endif
 
@@ -18,7 +30,7 @@ static void   pthread_create_once(void);
  * process goes multi-threaded.
  */
 
-#ifdef JEMALLOC_LAZY_LOCK
+#if defined(JEMALLOC_LAZY_LOCK) && !defined(_WIN32)
 static int (*pthread_create_fptr)(pthread_t *__restrict, const pthread_attr_t *,
     void *(*)(void *), void *__restrict);
 
@@ -36,8 +48,7 @@ pthread_create_once(void)
        isthreaded = true;
 }
 
-JEMALLOC_ATTR(visibility("default"))
-int
+JEMALLOC_EXPORT int
 pthread_create(pthread_t *__restrict thread,
     const pthread_attr_t *__restrict attr, void *(*start_routine)(void *),
     void *__restrict arg)
@@ -52,39 +63,87 @@ pthread_create(pthread_t *__restrict thread,
 
 /******************************************************************************/
 
+#ifdef JEMALLOC_MUTEX_INIT_CB
+int    _pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,
+    void *(calloc_cb)(size_t, size_t));
+#endif
+
 bool
 malloc_mutex_init(malloc_mutex_t *mutex)
 {
-#ifdef JEMALLOC_OSSPIN
-       *mutex = 0;
+
+#ifdef _WIN32
+       if (!InitializeCriticalSectionAndSpinCount(&mutex->lock,
+           _CRT_SPINCOUNT))
+               return (true);
+#elif (defined(JEMALLOC_OSSPIN))
+       mutex->lock = 0;
+#elif (defined(JEMALLOC_MUTEX_INIT_CB))
+       if (postpone_init) {
+               mutex->postponed_next = postponed_mutexes;
+               postponed_mutexes = mutex;
+       } else {
+               if (_pthread_mutex_init_calloc_cb(&mutex->lock, base_calloc) !=
+                   0)
+                       return (true);
+       }
 #else
        pthread_mutexattr_t attr;
 
        if (pthread_mutexattr_init(&attr) != 0)
                return (true);
-#ifdef PTHREAD_MUTEX_ADAPTIVE_NP
-       pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
-#else
-       pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
-#endif
-       if (pthread_mutex_init(mutex, &attr) != 0) {
+       pthread_mutexattr_settype(&attr, MALLOC_MUTEX_TYPE);
+       if (pthread_mutex_init(&mutex->lock, &attr) != 0) {
                pthread_mutexattr_destroy(&attr);
                return (true);
        }
        pthread_mutexattr_destroy(&attr);
-
 #endif
        return (false);
 }
 
 void
-malloc_mutex_destroy(malloc_mutex_t *mutex)
+malloc_mutex_prefork(malloc_mutex_t *mutex)
 {
 
-#ifndef JEMALLOC_OSSPIN
-       if (pthread_mutex_destroy(mutex) != 0) {
-               malloc_write("<jemalloc>: Error in pthread_mutex_destroy()\n");
-               abort();
+       malloc_mutex_lock(mutex);
+}
+
+void
+malloc_mutex_postfork_parent(malloc_mutex_t *mutex)
+{
+
+       malloc_mutex_unlock(mutex);
+}
+
+void
+malloc_mutex_postfork_child(malloc_mutex_t *mutex)
+{
+
+#ifdef JEMALLOC_MUTEX_INIT_CB
+       malloc_mutex_unlock(mutex);
+#else
+       if (malloc_mutex_init(mutex)) {
+               malloc_printf("<jemalloc>: Error re-initializing mutex in "
+                   "child\n");
+               if (opt_abort)
+                       abort();
        }
 #endif
 }
+
+bool
+mutex_boot(void)
+{
+
+#ifdef JEMALLOC_MUTEX_INIT_CB
+       postpone_init = false;
+       while (postponed_mutexes != NULL) {
+               if (_pthread_mutex_init_calloc_cb(&postponed_mutexes->lock,
+                   base_calloc) != 0)
+                       return (true);
+               postponed_mutexes = postponed_mutexes->postponed_next;
+       }
+#endif
+       return (false);
+}