struct freeable_stack *next;
#endif
os_thread_t os_thread;
- os_vm_address_t stack;
+ os_vm_address_t os_address;
};
#ifdef LOCK_CREATE_THREAD
static pthread_mutex_t create_thread_lock = PTHREAD_MUTEX_INITIALIZER;
#endif
+#ifdef LISP_FEATURE_GCC_TLS
+__thread struct thread *current_thread;
+#endif
#endif
#if defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)
#define THREAD_STRUCT_SIZE (THREAD_CONTROL_STACK_SIZE + BINDING_STACK_SIZE + \
ALIEN_STACK_SIZE + dynamic_values_bytes + \
- 32 * SIGSTKSZ)
+ 32 * SIGSTKSZ + \
+ BACKEND_PAGE_SIZE)
#ifdef LISP_FEATURE_SB_THREAD
static void
queue_freeable_thread_stack(struct thread *thread_to_be_cleaned_up)
{
+ struct freeable_stack *new_freeable_stack = 0;
if (thread_to_be_cleaned_up) {
+ /* FIXME: os_validate is mmap -- for small things like these
+ * malloc would probably perform better. */
+ new_freeable_stack = (struct freeable_stack *)
+ os_validate(0, sizeof(struct freeable_stack));
+ new_freeable_stack->next = NULL;
+ new_freeable_stack->os_thread = thread_to_be_cleaned_up->os_thread;
+ new_freeable_stack->os_address = thread_to_be_cleaned_up->os_address;
pthread_mutex_lock(&freeable_stack_lock);
if (freeable_stack_queue) {
- struct freeable_stack *new_freeable_stack = 0, *next;
+ struct freeable_stack *next;
next = freeable_stack_queue;
while (next->next) {
next = next->next;
}
- new_freeable_stack = (struct freeable_stack *)
- os_validate(0, sizeof(struct freeable_stack));
- new_freeable_stack->next = NULL;
- new_freeable_stack->os_thread = thread_to_be_cleaned_up->os_thread;
- new_freeable_stack->stack = (os_vm_address_t)
- thread_to_be_cleaned_up->control_stack_start;
next->next = new_freeable_stack;
- freeable_stack_count++;
} else {
- struct freeable_stack *new_freeable_stack = 0;
- new_freeable_stack = (struct freeable_stack *)
- os_validate(0, sizeof(struct freeable_stack));
- new_freeable_stack->next = NULL;
- new_freeable_stack->os_thread = thread_to_be_cleaned_up->os_thread;
- new_freeable_stack->stack = (os_vm_address_t)
- thread_to_be_cleaned_up->control_stack_start;
freeable_stack_queue = new_freeable_stack;
- freeable_stack_count++;
}
+ freeable_stack_count++;
pthread_mutex_unlock(&freeable_stack_lock);
}
}
freeable_stack_count--;
gc_assert(pthread_join(old->os_thread, NULL) == 0);
FSHOW((stderr, "freeing thread %x stack\n", old->os_thread));
- os_invalidate(old->stack, THREAD_STRUCT_SIZE);
+ os_invalidate(old->os_address, THREAD_STRUCT_SIZE);
os_invalidate((os_vm_address_t)old, sizeof(struct freeable_stack));
pthread_mutex_unlock(&freeable_stack_lock);
}
gc_assert(pthread_join(freeable->os_thread, NULL) == 0);
FSHOW((stderr, "/cleaner thread(%p): free stack %p\n",
self, freeable->stack));
- os_invalidate(freeable->stack, THREAD_STRUCT_SIZE);
+ os_invalidate(freeable->os_address, THREAD_STRUCT_SIZE);
free(freeable);
pthread_detach(self);
malloc(sizeof(struct freeable_stack));
gc_assert(freeable != NULL);
freeable->os_thread = thread_to_be_cleaned_up->os_thread;
- freeable->stack =
- (os_vm_address_t) thread_to_be_cleaned_up->control_stack_start;
+ freeable->os_address =
+ (os_vm_address_t) thread_to_be_cleaned_up->os_address;
result = pthread_create(&thread, NULL, cleanup_thread, freeable);
gc_assert(result == 0);
- sched_yield();
}
}
new_freeable_stack = (struct freeable_stack *)
os_validate(0, sizeof(struct freeable_stack));
new_freeable_stack->os_thread = thread_to_be_cleaned_up->os_thread;
- new_freeable_stack->stack = (os_vm_address_t)
- thread_to_be_cleaned_up->control_stack_start;
+ new_freeable_stack->os_address = (os_vm_address_t)
+ thread_to_be_cleaned_up->os_address;
}
new_freeable_stack = (struct freeable_stack *)
swap_lispobjs((lispobj *)(void *)&freeable_stack,
* exists and the stack can be safely freed. This is sadly not
* mandated by the pthread spec. */
gc_assert(pthread_join(new_freeable_stack->os_thread, NULL) == 0);
- os_invalidate(new_freeable_stack->stack, THREAD_STRUCT_SIZE);
+ os_invalidate(new_freeable_stack->os_address, THREAD_STRUCT_SIZE);
os_invalidate((os_vm_address_t) new_freeable_stack,
sizeof(struct freeable_stack));
}
if (th->interrupt_data)
os_invalidate((os_vm_address_t) th->interrupt_data,
(sizeof (struct interrupt_data)));
- os_invalidate((os_vm_address_t) th->control_stack_start,
+ os_invalidate((os_vm_address_t) th->os_address,
THREAD_STRUCT_SIZE);
}
union per_thread_data *per_thread;
struct thread *th=0; /* subdue gcc */
void *spaces=0;
+ void *aligned_spaces=0;
#ifdef LISP_FEATURE_SB_THREAD
int i;
#endif
-#ifdef CREATE_CLEANUP_THREAD
- /* Give a chance for cleanup threads to run. */
- sched_yield();
-#endif
/* May as well allocate all the spaces at once: it saves us from
* having to decide what to do if only some of the allocations
* succeed. SPACES must be page-aligned, since the GC expects the
* alignment passed from os_validate, since that might assume the
* current (e.g. 4k) pagesize, while we calculate with the biggest
* (e.g. 64k) pagesize allowed by the ABI. */
- spaces=os_validate(0, THREAD_STRUCT_SIZE + BACKEND_PAGE_SIZE);
+ spaces=os_validate(0, THREAD_STRUCT_SIZE);
if(!spaces)
- return NULL;
- spaces = (void *)((((unsigned long)(char *)spaces)
- + BACKEND_PAGE_SIZE - 1)
- & ~(BACKEND_PAGE_SIZE - 1));
+ return NULL;
+ /* Aligning up is safe as THREAD_STRUCT_SIZE has BACKEND_PAGE_SIZE
+ * padding. */
+ aligned_spaces = (void *)((((unsigned long)(char *)spaces)
+ + BACKEND_PAGE_SIZE - 1)
+ & ~(unsigned long)(BACKEND_PAGE_SIZE - 1));
per_thread=(union per_thread_data *)
- (spaces+
+ (aligned_spaces+
THREAD_CONTROL_STACK_SIZE+
BINDING_STACK_SIZE+
ALIEN_STACK_SIZE);
#endif
th=&per_thread->thread;
- th->control_stack_start = spaces;
+ th->os_address = spaces;
+ th->control_stack_start = aligned_spaces;
th->binding_stack_start=
(lispobj*)((void*)th->control_stack_start+THREAD_CONTROL_STACK_SIZE);
th->control_stack_end = th->binding_stack_start;
pthread_attr_t attr;
sigset_t newset,oldset;
boolean r=1;
- int retcode, initcode, sizecode, addrcode;
+ int retcode = 0, initcode;
FSHOW_SIGNAL((stderr,"/create_os_thread: creating new thread\n"));
#undef CONTROL_STACK_ADJUST
(retcode = pthread_create
(kid_tid,&attr,(void *(*)(void *))new_thread_trampoline,th))) {
- FSHOW_SIGNAL((stderr, "init, size, addr = %d, %d, %d\n", initcode, sizecode, addrcode));
+ FSHOW_SIGNAL((stderr, "init = %d\n", initcode));
FSHOW_SIGNAL((stderr, printf("pthread_create returned %d, errno %d\n", retcode, errno)));
FSHOW_SIGNAL((stderr, "wanted stack size %d, min stack size %d\n",
THREAD_CONTROL_STACK_SIZE-16, PTHREAD_STACK_MIN));
FSHOW_SIGNAL((stderr,"/gc_start_the_world:end\n"));
}
#endif
+
+int
+thread_yield()
+{
+#ifdef LISP_FEATURE_SB_THREAD
+ return sched_yield();
+#else
+ return 0;
+#endif
+}