void erts_lc_init(void) { #ifdef ERTS_LC_STATIC_ALLOC int i; static erts_lc_free_block_t fbs[ERTS_LC_FB_CHUNK_SIZE]; for (i = 0; i < ERTS_LC_FB_CHUNK_SIZE - 1; i++) { #ifdef DEBUG memset((void *) &fbs[i], 0xdf, sizeof(erts_lc_free_block_t)); #endif fbs[i].next = &fbs[i+1]; } #ifdef DEBUG memset((void *) &fbs[ERTS_LC_FB_CHUNK_SIZE-1], 0xdf, sizeof(erts_lc_free_block_t)); #endif fbs[ERTS_LC_FB_CHUNK_SIZE-1].next = NULL; free_blocks = &fbs[0]; #else /* #ifdef ERTS_LC_STATIC_ALLOC */ free_blocks = NULL; #endif /* #ifdef ERTS_LC_STATIC_ALLOC */ if (ethr_spinlock_init(&free_blocks_lock) != 0) lc_abort(); erts_tsd_key_create(&locks_key); }
static int init_ts_event_alloc(void) { free_ts_ev = ts_event_pool(ERTS_TS_EV_ALLOC_DEFAULT_POOL_SIZE, NULL); if (!free_ts_ev) return ENOMEM; return ethr_spinlock_init(&ts_ev_alloc_lock); }
void erts_lc_init(void) { if (ethr_spinlock_init(&lc_threads_lock) != 0) ERTS_INTERNAL_ERROR("spinlock_init failed"); erts_tsd_key_create(&locks_key,"erts_lock_check_key"); }
static void spinlock_test(void) { int res; ethr_tid tid; print_line("Trying to initialize spinlock"); res = ethr_spinlock_init(&st_spinlock); ASSERT(res == 0); print_line("Initialized spinlock"); st_data = 0; print_line("Main thread tries to lock spinlock"); ethr_spin_lock(&st_spinlock); print_line("Main thread locked spinlock"); ASSERT(st_data == 0); print_line("Main thread about to create aux thread"); res = ethr_thr_create(&tid, st_thread, NULL, NULL); ASSERT(res == 0); print_line("Main thread created aux thread"); print_line("Main thread goes to sleep for 1 second"); do_sleep(1); print_line("Main thread woke up"); ASSERT(st_data == 0); ethr_spin_unlock(&st_spinlock); print_line("Main thread unlocked spinlock"); print_line("Main thread goes to sleep for 1 second"); do_sleep(1); print_line("Main thread woke up"); print_line("Main thread tries to lock spinlock"); ethr_spin_lock(&st_spinlock); print_line("Main thread locked spinlock"); ASSERT(st_data == 1); print_line("Main thread goes to sleep for 1 second"); do_sleep(1); print_line("Main thread woke up"); ASSERT(st_data == 1); ethr_spin_unlock(&st_spinlock); print_line("Main thread unlocked spinlock"); res = ethr_thr_join(tid, NULL); ASSERT(res == 0); print_line("Main thread joined aux thread"); res = ethr_spinlock_destroy(&st_spinlock); ASSERT(res == 0); print_line("Main thread destroyed spinlock"); }
int ethr_init_common__(ethr_init_data *id) { int res; if (id) { ethr_thr_prepare_func__ = id->thread_create_prepare_func; ethr_thr_parent_func__ = id->thread_create_parent_func; ethr_thr_child_func__ = id->thread_create_child_func; } ethr_cpu_info__ = erts_cpu_info_create(); if (!ethr_cpu_info__) return ENOMEM; #ifdef _SC_PAGESIZE ethr_pagesize__ = (size_t) sysconf(_SC_PAGESIZE); #elif defined(HAVE_GETPAGESIZE) ethr_pagesize__ = (size_t) getpagesize(); #else ethr_pagesize__ = (size_t) 4*1024; /* Guess 4 KB */ #endif /* User needs at least 4 KB */ ethr_min_stack_size__ = 4*1024; #if SIZEOF_VOID_P == 8 /* Double that on 64-bit archs */ ethr_min_stack_size__ *= 2; #endif /* On some systems as much as about 4 KB is used by the system */ ethr_min_stack_size__ += 4*1024; /* There should be room for signal handlers */ #ifdef SIGSTKSZ ethr_min_stack_size__ += SIGSTKSZ; #else ethr_min_stack_size__ += ethr_pagesize__; #endif /* The system may think that we need more stack */ #if defined(PTHREAD_STACK_MIN) if (ethr_min_stack_size__ < PTHREAD_STACK_MIN) ethr_min_stack_size__ = PTHREAD_STACK_MIN; #elif defined(_SC_THREAD_STACK_MIN) { size_t thr_min_stk_sz = (size_t) sysconf(_SC_THREAD_STACK_MIN); if (ethr_min_stack_size__ < thr_min_stk_sz) ethr_min_stack_size__ = thr_min_stk_sz; } #endif /* The guard is at least on some platforms included in the stack size passed when creating threads */ #ifdef ETHR_STACK_GUARD_SIZE ethr_min_stack_size__ += ETHR_STACK_GUARD_SIZE; #endif ethr_min_stack_size__ = ETHR_PAGE_ALIGN(ethr_min_stack_size__); ethr_min_stack_size__ = ETHR_B2KW(ethr_min_stack_size__); ethr_max_stack_size__ = 32*1024*1024; #if SIZEOF_VOID_P == 8 ethr_max_stack_size__ *= 2; #endif ethr_max_stack_size__ = ETHR_B2KW(ethr_max_stack_size__); #ifndef ETHR_HAVE_OPTIMIZED_ATOMIC_OPS { int i; for (i = 0; i < (1 << ETHR_ATOMIC_ADDR_BITS); i++) { res = ethr_spinlock_init(ðr_atomic_protection__[i].u.lck); if (res != 0) return res; } } #endif res = ethr_mutex_lib_init(erts_get_cpu_configured(ethr_cpu_info__)); if (res != 0) return res; xhndl_list = NULL; return 0; }