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;
}
