X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fthread.c;h=78a3ec33bc32df7890fae822a8d68473b4822f41;hb=d4b738d6c0b354de817fa490b50814e40872b3d0;hp=45086ebadcfba3b104a4c0e99c08ed26758fe91c;hpb=d767105094f5836327f9389b061f83a44240a279;p=sbcl.git

diff --git a/src/runtime/thread.c b/src/runtime/thread.c
index 45086eb..78a3ec3 100644
--- a/src/runtime/thread.c
+++ b/src/runtime/thread.c
@@ -24,6 +24,7 @@
 int dynamic_values_bytes=4096*sizeof(lispobj);	/* same for all threads */
 struct thread *all_threads;
 lispobj all_threads_lock;
+int countdown_to_gc;
 extern struct interrupt_data * global_interrupt_data;
 
 void get_spinlock(lispobj *word,int value);
@@ -120,8 +121,10 @@ pid_t create_thread(lispobj initial_function) {
 	STATIC_TLS_INIT(CONTROL_STACK_START,control_stack_start);
 	STATIC_TLS_INIT(CONTROL_STACK_END,control_stack_end);
 	STATIC_TLS_INIT(ALIEN_STACK,alien_stack_pointer);
+#ifdef LISP_FEATURE_X86
 	STATIC_TLS_INIT(PSEUDO_ATOMIC_ATOMIC,pseudo_atomic_atomic);
 	STATIC_TLS_INIT(PSEUDO_ATOMIC_INTERRUPTED,pseudo_atomic_interrupted);
+#endif
 #undef STATIC_TLS_INIT
 #endif
     }
@@ -141,10 +144,12 @@ pid_t create_thread(lispobj initial_function) {
 #else
     th->alien_stack_pointer=((void *)th->alien_stack_start);
 #endif
+#ifdef LISP_FEATURE_X86
     th->pseudo_atomic_interrupted=0;
     /* runtime.c used to set PSEUDO_ATOMIC_ATOMIC =1 globally.  I'm not
      * sure why, but it appears to help */
     th->pseudo_atomic_atomic=make_fixnum(1);
+#endif
 #ifdef LISP_FEATURE_GENCGC
     gc_set_region_empty(&th->alloc_region);
 #endif
@@ -175,7 +180,7 @@ pid_t create_thread(lispobj initial_function) {
     bind_variable(INTERRUPT_PENDING, NIL,th);
     bind_variable(INTERRUPTS_ENABLED,T,th);
 
-    th->interrupt_data=malloc(sizeof (struct interrupt_data));
+    th->interrupt_data=os_validate(0,(sizeof (struct interrupt_data)));
     if(all_threads) 
 	memcpy(th->interrupt_data,
 	       arch_os_get_current_thread()->interrupt_data,
@@ -207,7 +212,7 @@ pid_t create_thread(lispobj initial_function) {
      * to ensure that we don't have >1 thread with pid=0 on the list at once
      */
     protect_control_stack_guard_page(th->pid,1);
-    all_threads_lock=0;
+    release_spinlock(&all_threads_lock);
     th->pid=kid_pid;		/* child will not start until this is set */
 #ifndef LISP_FEATURE_SB_THREAD
     new_thread_trampoline(all_threads);	/*  call_into_lisp */
@@ -231,6 +236,7 @@ void destroy_thread (struct thread *th)
     gc_alloc_update_page_tables(0, &th->alloc_region);
 #endif
     get_spinlock(&all_threads_lock,th->pid);
+    if(countdown_to_gc>0) countdown_to_gc--;
     if(th==all_threads) 
 	all_threads=th->next;
     else {
@@ -238,11 +244,12 @@ void destroy_thread (struct thread *th)
 	while(th1->next!=th) th1=th1->next;
 	th1->next=th->next;	/* unlink */
     }
-    all_threads_lock=0;
+    release_spinlock(&all_threads_lock);
     if(th && th->tls_cookie>=0) arch_os_thread_cleanup(th); 
     os_invalidate((os_vm_address_t) th->control_stack_start,
-		  THREAD_CONTROL_STACK_SIZE+BINDING_STACK_SIZE+
-		  ALIEN_STACK_SIZE+dynamic_values_bytes+
+		  ((sizeof (lispobj))
+		   * (th->control_stack_end-th->control_stack_start)) +
+		  BINDING_STACK_SIZE+ALIEN_STACK_SIZE+dynamic_values_bytes+
 		  32*SIGSTKSZ);
 }
 
@@ -266,6 +273,10 @@ void block_sigcont(void)
     sigprocmask(SIG_BLOCK, &newset, 0); 
 }
 
+/* This is not needed unless #+SB-THREAD, and since sigwaitinfo()
+ * doesn't seem to be easily available everywhere (OpenBSD...) it's
+ * more trouble than it's worth to compile it when not needed. */
+#if defined LISP_FEATURE_SB_THREAD
 void unblock_sigcont_and_sleep(void)
 {
     sigset_t set;
@@ -274,3 +285,50 @@ void unblock_sigcont_and_sleep(void)
     sigwaitinfo(&set,0);
     sigprocmask(SIG_UNBLOCK,&set,0);
 }
+
+int interrupt_thread(pid_t pid, lispobj function)
+{
+    union sigval sigval;
+    sigval.sival_int=function;
+
+    return sigqueue(pid, SIG_INTERRUPT_THREAD, sigval);
+}
+
+void gc_stop_the_world()
+{
+    /* stop all other threads by sending them SIG_STOP_FOR_GC */
+    struct thread *p,*th=arch_os_get_current_thread();
+    struct thread *tail=0;
+    int finished=0;
+    do {
+	get_spinlock(&all_threads_lock,th->pid);
+	if(tail!=all_threads) {
+	    /* new threads always get consed onto the front of all_threads,
+	     * and may be created by any thread that we haven't signalled
+	     * yet or hasn't received our signal and stopped yet.  So, check
+	     * for them on each time around */
+	    for(p=all_threads;p!=tail;p=p->next) {
+		if(p==th) continue;
+		countdown_to_gc++;
+		kill(p->pid,SIG_STOP_FOR_GC);
+	    }
+	    tail=all_threads;
+	} else {
+	    finished=(countdown_to_gc==0);
+	}
+	release_spinlock(&all_threads_lock);
+	sched_yield();
+    } while(!finished);
+}
+
+void gc_start_the_world()
+{
+    struct thread *p,*th=arch_os_get_current_thread();
+    get_spinlock(&all_threads_lock,th->pid);
+    for(p=all_threads;p;p=p->next) {
+	if(p==th) continue;
+	kill(p->pid,SIGCONT);
+    }
+    release_spinlock(&all_threads_lock);
+}
+#endif