contrib/jemalloc/src/tsd.c

   1 #define JEMALLOC_TSD_C_
   2 #include "jemalloc/internal/jemalloc_preamble.h"
   3 #include "jemalloc/internal/jemalloc_internal_includes.h"
   4
   5 #include "jemalloc/internal/assert.h"
   6 #include "jemalloc/internal/mutex.h"
   7 #include "jemalloc/internal/rtree.h"
   8
   9 /******************************************************************************/
  10 /* Data. */
  11
  12 static unsigned ncleanups;
  13 static malloc_tsd_cleanup_t cleanups[MALLOC_TSD_CLEANUPS_MAX];
  14
  15 #ifdef JEMALLOC_MALLOC_THREAD_CLEANUP
  16 __thread tsd_t JEMALLOC_TLS_MODEL tsd_tls = TSD_INITIALIZER;
  17 __thread bool JEMALLOC_TLS_MODEL tsd_initialized = false;
  18 bool tsd_booted = false;
  19 #elif (defined(JEMALLOC_TLS))
  20 __thread tsd_t JEMALLOC_TLS_MODEL tsd_tls = TSD_INITIALIZER;
  21 pthread_key_t tsd_tsd;
  22 bool tsd_booted = false;
  23 #elif (defined(_WIN32))
  24 DWORD tsd_tsd;
  25 tsd_wrapper_t tsd_boot_wrapper = {false, TSD_INITIALIZER};
  26 bool tsd_booted = false;
  27 #else
  28
  29 /*
  30  * This contains a mutex, but it's pretty convenient to allow the mutex code to
  31  * have a dependency on tsd.  So we define the struct here, and only refer to it
  32  * by pointer in the header.
  33  */
  34 struct tsd_init_head_s {
  35         ql_head(tsd_init_block_t) blocks;
  36         malloc_mutex_t lock;
  37 };
  38
  39 pthread_key_t tsd_tsd;
  40 tsd_init_head_t tsd_init_head = {
  41         ql_head_initializer(blocks),
  42         MALLOC_MUTEX_INITIALIZER
  43 };
  44 tsd_wrapper_t tsd_boot_wrapper = {
  45         false,
  46         TSD_INITIALIZER
  47 };
  48 bool tsd_booted = false;
  49 #endif
  50
  51
  52 /******************************************************************************/
  53
  54 void
  55 tsd_slow_update(tsd_t *tsd) {
  56         if (tsd_nominal(tsd)) {
  57                 if (malloc_slow || !tsd_tcache_enabled_get(tsd) ||
  58                     tsd_reentrancy_level_get(tsd) > 0) {
  59                         tsd->state = tsd_state_nominal_slow;
  60                 } else {
  61                         tsd->state = tsd_state_nominal;
  62                 }
  63         }
  64 }
  65
  66 static bool
  67 tsd_data_init(tsd_t *tsd) {
  68         /*
  69          * We initialize the rtree context first (before the tcache), since the
  70          * tcache initialization depends on it.
  71          */
  72         rtree_ctx_data_init(tsd_rtree_ctxp_get_unsafe(tsd));
  73
  74         return tsd_tcache_enabled_data_init(tsd);
  75 }
  76
  77 static void
  78 assert_tsd_data_cleanup_done(tsd_t *tsd) {
  79         assert(!tsd_nominal(tsd));
  80         assert(*tsd_arenap_get_unsafe(tsd) == NULL);
  81         assert(*tsd_iarenap_get_unsafe(tsd) == NULL);
  82         assert(*tsd_arenas_tdata_bypassp_get_unsafe(tsd) == true);
  83         assert(*tsd_arenas_tdatap_get_unsafe(tsd) == NULL);
  84         assert(*tsd_tcache_enabledp_get_unsafe(tsd) == false);
  85         assert(*tsd_prof_tdatap_get_unsafe(tsd) == NULL);
  86 }
  87
  88 static bool
  89 tsd_data_init_nocleanup(tsd_t *tsd) {
  90         assert(tsd->state == tsd_state_reincarnated);
  91         /*
  92          * During reincarnation, there is no guarantee that the cleanup function
  93          * will be called (deallocation may happen after all tsd destructors).
  94          * We set up tsd in a way that no cleanup is needed.
  95          */
  96         rtree_ctx_data_init(tsd_rtree_ctxp_get_unsafe(tsd));
  97         *tsd_arenas_tdata_bypassp_get(tsd) = true;
  98         *tsd_tcache_enabledp_get_unsafe(tsd) = false;
  99         *tsd_reentrancy_levelp_get(tsd) = 1;
 100         assert_tsd_data_cleanup_done(tsd);
 101
 102         return false;
 103 }
 104
 105 tsd_t *
 106 tsd_fetch_slow(tsd_t *tsd, bool internal) {
 107         if (internal) {
 108                 /* For internal background threads use only. */
 109                 assert(tsd->state == tsd_state_uninitialized);
 110                 tsd->state = tsd_state_reincarnated;
 111                 tsd_set(tsd);
 112                 tsd_data_init_nocleanup(tsd);
 113                 return tsd;
 114         }
 115
 116         if (tsd->state == tsd_state_nominal_slow) {
 117                 /* On slow path but no work needed. */
 118                 assert(malloc_slow || !tsd_tcache_enabled_get(tsd) ||
 119                     tsd_reentrancy_level_get(tsd) > 0 ||
 120                     *tsd_arenas_tdata_bypassp_get(tsd));
 121         } else if (tsd->state == tsd_state_uninitialized) {
 122                 tsd->state = tsd_state_nominal;
 123                 tsd_slow_update(tsd);
 124                 /* Trigger cleanup handler registration. */
 125                 tsd_set(tsd);
 126                 tsd_data_init(tsd);
 127         } else if (tsd->state == tsd_state_purgatory) {
 128                 tsd->state = tsd_state_reincarnated;
 129                 tsd_set(tsd);
 130                 tsd_data_init_nocleanup(tsd);
 131         } else {
 132                 assert(tsd->state == tsd_state_reincarnated);
 133         }
 134
 135         return tsd;
 136 }
 137
 138 void *
 139 malloc_tsd_malloc(size_t size) {
 140         return a0malloc(CACHELINE_CEILING(size));
 141 }
 142
 143 void
 144 malloc_tsd_dalloc(void *wrapper) {
 145         a0dalloc(wrapper);
 146 }
 147
 148 #if defined(JEMALLOC_MALLOC_THREAD_CLEANUP) || defined(_WIN32)
 149 #ifndef _WIN32
 150 JEMALLOC_EXPORT
 151 #endif
 152 void
 153 _malloc_thread_cleanup(void) {
 154         bool pending[MALLOC_TSD_CLEANUPS_MAX], again;
 155         unsigned i;
 156
 157         for (i = 0; i < ncleanups; i++) {
 158                 pending[i] = true;
 159         }
 160
 161         do {
 162                 again = false;
 163                 for (i = 0; i < ncleanups; i++) {
 164                         if (pending[i]) {
 165                                 pending[i] = cleanups[i]();
 166                                 if (pending[i]) {
 167                                         again = true;
 168                                 }
 169                         }
 170                 }
 171         } while (again);
 172 }
 173 #endif
 174
 175 void
 176 malloc_tsd_cleanup_register(bool (*f)(void)) {
 177         assert(ncleanups < MALLOC_TSD_CLEANUPS_MAX);
 178         cleanups[ncleanups] = f;
 179         ncleanups++;
 180 }
 181
 182 static void
 183 tsd_do_data_cleanup(tsd_t *tsd) {
 184         prof_tdata_cleanup(tsd);
 185         iarena_cleanup(tsd);
 186         arena_cleanup(tsd);
 187         arenas_tdata_cleanup(tsd);
 188         tcache_cleanup(tsd);
 189         witnesses_cleanup(tsd_witness_tsdp_get_unsafe(tsd));
 190 }
 191
 192 void
 193 tsd_cleanup(void *arg) {
 194         tsd_t *tsd = (tsd_t *)arg;
 195
 196         switch (tsd->state) {
 197         case tsd_state_uninitialized:
 198                 /* Do nothing. */
 199                 break;
 200         case tsd_state_reincarnated:
 201                 /*
 202                  * Reincarnated means another destructor deallocated memory
 203                  * after the destructor was called.  Cleanup isn't required but
 204                  * is still called for testing and completeness.
 205                  */
 206                 assert_tsd_data_cleanup_done(tsd);
 207                 /* Fall through. */
 208         case tsd_state_nominal:
 209         case tsd_state_nominal_slow:
 210                 tsd_do_data_cleanup(tsd);
 211                 tsd->state = tsd_state_purgatory;
 212                 tsd_set(tsd);
 213                 break;
 214         case tsd_state_purgatory:
 215                 /*
 216                  * The previous time this destructor was called, we set the
 217                  * state to tsd_state_purgatory so that other destructors
 218                  * wouldn't cause re-creation of the tsd.  This time, do
 219                  * nothing, and do not request another callback.
 220                  */
 221                 break;
 222         default:
 223                 not_reached();
 224         }
 225 #ifdef JEMALLOC_JET
 226         test_callback_t test_callback = *tsd_test_callbackp_get_unsafe(tsd);
 227         int *data = tsd_test_datap_get_unsafe(tsd);
 228         if (test_callback != NULL) {
 229                 test_callback(data);
 230         }
 231 #endif
 232 }
 233
 234 tsd_t *
 235 malloc_tsd_boot0(void) {
 236         tsd_t *tsd;
 237
 238         ncleanups = 0;
 239         if (tsd_boot0()) {
 240                 return NULL;
 241         }
 242         tsd = tsd_fetch();
 243         *tsd_arenas_tdata_bypassp_get(tsd) = true;
 244         return tsd;
 245 }
 246
 247 void
 248 malloc_tsd_boot1(void) {
 249         tsd_boot1();
 250         tsd_t *tsd = tsd_fetch();
 251         /* malloc_slow has been set properly.  Update tsd_slow. */
 252         tsd_slow_update(tsd);
 253         *tsd_arenas_tdata_bypassp_get(tsd) = false;
 254 }
 255
 256 #ifdef _WIN32
 257 static BOOL WINAPI
 258 _tls_callback(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
 259         switch (fdwReason) {
 260 #ifdef JEMALLOC_LAZY_LOCK
 261         case DLL_THREAD_ATTACH:
 262                 isthreaded = true;
 263                 break;
 264 #endif
 265         case DLL_THREAD_DETACH:
 266                 _malloc_thread_cleanup();
 267                 break;
 268         default:
 269                 break;
 270         }
 271         return true;
 272 }
 273
 274 /*
 275  * We need to be able to say "read" here (in the "pragma section"), but have
 276  * hooked "read". We won't read for the rest of the file, so we can get away
 277  * with unhooking.
 278  */
 279 #ifdef read
 280 #  undef read
 281 #endif
 282
 283 #ifdef _MSC_VER
 284 #  ifdef _M_IX86
 285 #    pragma comment(linker, "/INCLUDE:__tls_used")
 286 #    pragma comment(linker, "/INCLUDE:_tls_callback")
 287 #  else
 288 #    pragma comment(linker, "/INCLUDE:_tls_used")
 289 #    pragma comment(linker, "/INCLUDE:tls_callback")
 290 #  endif
 291 #  pragma section(".CRT$XLY",long,read)
 292 #endif
 293 JEMALLOC_SECTION(".CRT$XLY") JEMALLOC_ATTR(used)
 294 BOOL    (WINAPI *const tls_callback)(HINSTANCE hinstDLL,
 295     DWORD fdwReason, LPVOID lpvReserved) = _tls_callback;
 296 #endif
 297
 298 #if (!defined(JEMALLOC_MALLOC_THREAD_CLEANUP) && !defined(JEMALLOC_TLS) && \
 299     !defined(_WIN32))
 300 void *
 301 tsd_init_check_recursion(tsd_init_head_t *head, tsd_init_block_t *block) {
 302         pthread_t self = pthread_self();
 303         tsd_init_block_t *iter;
 304
 305         /* Check whether this thread has already inserted into the list. */
 306         malloc_mutex_lock(TSDN_NULL, &head->lock);
 307         ql_foreach(iter, &head->blocks, link) {
 308                 if (iter->thread == self) {
 309                         malloc_mutex_unlock(TSDN_NULL, &head->lock);
 310                         return iter->data;
 311                 }
 312         }
 313         /* Insert block into list. */
 314         ql_elm_new(block, link);
 315         block->thread = self;
 316         ql_tail_insert(&head->blocks, block, link);
 317         malloc_mutex_unlock(TSDN_NULL, &head->lock);
 318         return NULL;
 319 }
 320
 321 void
 322 tsd_init_finish(tsd_init_head_t *head, tsd_init_block_t *block) {
 323         malloc_mutex_lock(TSDN_NULL, &head->lock);
 324         ql_remove(&head->blocks, block, link);
 325         malloc_mutex_unlock(TSDN_NULL, &head->lock);
 326 }
 327 #endif