0.8.6.38

	The long-threatened removal of the 'parent' thread.  Now SBCL
	only uses one thread until you start the second one

	Also removed countdown_to_gc: it's redundant now we have
	a thread->state slot

src/runtime/interrupt.c

@@ -74,7 +74,6 @@ static void store_signal_data_for_later (struct interrupt_data *data,
 boolean interrupt_maybe_gc_int(int signal, siginfo_t *info, void *v_context);
 
 extern volatile lispobj all_threads_lock;
-extern volatile int countdown_to_gc;
 
 /*
  * This is a workaround for some slightly silly Linux/GNU Libc
@@ -555,7 +554,6 @@ sig_stop_for_gc_handler(int signal, siginfo_t *info, void *void_context)
     fake_foreign_function_call(context); 
 
     get_spinlock(&all_threads_lock,thread->pid);
-    countdown_to_gc--;
     thread->state=STATE_STOPPED;
     release_spinlock(&all_threads_lock);
     kill(thread->pid,SIGSTOP);

src/runtime/runtime.c

@@ -335,51 +335,7 @@ main(int argc, char *argv[], char *envp[])
     sigint_init();
 
     FSHOW((stderr, "/funcalling initial_function=0x%lx\n", initial_function));
-    create_thread(initial_function);
-    /* in a unithread build, create_thread never returns */
-#ifdef LISP_FEATURE_SB_THREAD
-    parent_loop();
-#endif
+    create_initial_thread(initial_function);
+    lose("CATS.  CATS ARE NICE.");
 }
 
-#ifdef LISP_FEATURE_SB_THREAD
-
-/* this is being pared down as time goes on; eventually we want to get
- * to the point that we have no parent loop at all and the parent
- * thread runs Lisp just like any other */
-
-static void /* noreturn */ parent_loop(void)
-{
-    struct sigaction sa;
-    sigset_t sigset;
-    int status;
-    pid_t pid=0;
-
-    sigemptyset(&sigset);
-    sa.sa_handler=SIG_IGN;
-    sa.sa_mask=sigset;
-    sa.sa_flags=0;
-    sigaction(SIGINT, &sa, 0); 	/* ^c should go to the lisp thread instead */
-    sigaction(SIG_THREAD_EXIT, &sa, 0);
-    sigaction(SIGCHLD, &sa, 0);
-
-    while(!all_threads) {
-	sched_yield();
-    }
-    while(all_threads && (pid=waitpid(-1,&status,__WALL))) {
-	struct thread *th;
-	if(pid==-1) {
-	    if(errno == EINTR) continue;
-	    fprintf(stderr,"waitpid: %s\n",strerror(errno));
-	}
-	else if(WIFEXITED(status) || WIFSIGNALED(status)) {
-	    th=find_thread_by_pid(pid);
-	    if(!th) continue;
-	    destroy_thread(th);
-	    if(!all_threads) break;
-	}
-    }
-    exit(WEXITSTATUS(status));
-}
-
-#endif

src/runtime/thread.c

@@ -19,62 +19,58 @@
 int dynamic_values_bytes=4096*sizeof(lispobj);	/* same for all threads */
 struct thread *all_threads;
 volatile lispobj all_threads_lock;
-volatile int countdown_to_gc;
 extern struct interrupt_data * global_interrupt_data;
 
 void get_spinlock(lispobj *word,int value);
 
+int
+initial_thread_trampoline(struct thread *th)
+{
+    lispobj function;
+    lispobj *args = NULL;
+    function = th->unbound_marker;
+    th->unbound_marker = UNBOUND_MARKER_WIDETAG;
+    if(arch_os_thread_init(th)==0) return 1;
+
+    if(th->pid < 1) lose("th->pid not set up right");
+    th->state=STATE_RUNNING;
+#if defined(LISP_FEATURE_X86)
+    return call_into_lisp_first_time(function,args,0);
+#else
+    return funcall0(function);
+#endif
+}
+
 /* this is the first thing that clone() runs in the child (which is
  * why the silly calling convention).  Basically it calls the user's
  * requested lisp function after doing arch_os_thread_init and
  * whatever other bookkeeping needs to be done
  */
 
-/* set go to 0 to stop the thread before it starts.  Convenient if you
-* want to attach a debugger to it before it does anything */
-volatile int go=1;		
-
 int
 new_thread_trampoline(struct thread *th)
 {
     lispobj function;
-    lispobj *args = NULL;
     function = th->unbound_marker;
-    if(go==0) {
-	fprintf(stderr, "/pausing 0x%lx(%d,%d) before new_thread_trampoline(0x%lx)\n",
-		(unsigned long)th,th->pid,getpid(),(unsigned long)function);
-	while(go==0) ;
-	fprintf(stderr, "/continue\n");
-    }
     th->unbound_marker = UNBOUND_MARKER_WIDETAG;
-    if(arch_os_thread_init(th)==0) 
-	return 1;		/* failure.  no, really */
-#ifdef LISP_FEATURE_SB_THREAD
+    if(arch_os_thread_init(th)==0) return 1;	
+
     /* wait here until our thread is linked into all_threads: see below */
     while(th->pid<1) sched_yield();
-#else
-    if(th->pid < 1)
-	lose("th->pid not set up right");
-#endif
 
     th->state=STATE_RUNNING;
-#if !defined(LISP_FEATURE_SB_THREAD) && defined(LISP_FEATURE_X86)
-    return call_into_lisp_first_time(function,args,0);
-#else
     return funcall0(function);
-#endif
 }
 
 /* this is called from any other thread to create the new one, and
  * initialize all parts of it that can be initialized from another 
  * thread 
  */
 
-pid_t create_thread(lispobj initial_function) {
+struct thread * create_thread_struct(lispobj initial_function) {
     union per_thread_data *per_thread;
     struct thread *th=0;	/*  subdue gcc */
     void *spaces=0;
-    pid_t kid_pid;
 
     /* 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
@@ -185,20 +181,17 @@ pid_t create_thread(lispobj initial_function) {
 	       sizeof (struct interrupt_data));
 
     th->unbound_marker=initial_function;
-#ifdef LISP_FEATURE_SB_THREAD
-#if defined(LISP_FEATURE_X86) && defined (LISP_FEATURE_LINUX)
-    kid_pid=
-	clone(new_thread_trampoline,
-	      (((void*)th->control_stack_start)+THREAD_CONTROL_STACK_SIZE-4),
-	      CLONE_FILES|SIG_THREAD_EXIT|CLONE_VM,th);
-    if(kid_pid<=0) 
-	goto cleanup;
-#else
-#error this stuff presently only works on x86 Linux
-#endif
-#else
-    kid_pid=getpid();
-#endif
+    return th;
+ cleanup:
+    /* if(th && th->tls_cookie>=0) os_free_tls_pointer(th); */
+    if(spaces) os_invalidate(spaces,
+			     THREAD_CONTROL_STACK_SIZE+BINDING_STACK_SIZE+
+			     ALIEN_STACK_SIZE+dynamic_values_bytes);
+    return 0;
+}
+
+void link_thread(struct thread *th,pid_t kid_pid)
+{
     get_spinlock(&all_threads_lock,kid_pid);
     th->next=all_threads;
     all_threads=th;
@@ -208,20 +201,35 @@ pid_t create_thread(lispobj initial_function) {
     protect_control_stack_guard_page(th->pid,1);
     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 */
-    lose("Clever child?  Idiot savant, verging on the.");
-#endif
+}
 
-    return th->pid;
- cleanup:
-    /* if(th && th->tls_cookie>=0) os_free_tls_pointer(th); */
-    if(spaces) os_invalidate(spaces,
-			     THREAD_CONTROL_STACK_SIZE+BINDING_STACK_SIZE+
-			     ALIEN_STACK_SIZE+dynamic_values_bytes);
-    return 0;
+pid_t create_initial_thread(lispobj initial_function) {
+    struct thread *th=create_thread_struct(initial_function);
+    pid_t kid_pid=getpid();
+    if(th && kid_pid>0) {
+	link_thread(th,kid_pid);
+	initial_thread_trampoline(all_threads); /* no return */
+    } else lose("can't create initial thread");
 }
 
+#ifdef LISP_FEATURE_LINUX
+pid_t create_thread(lispobj initial_function) {
+    struct thread *th=create_thread_struct(initial_function);
+    pid_t kid_pid=clone(new_thread_trampoline,
+			(((void*)th->control_stack_start)+
+			 THREAD_CONTROL_STACK_SIZE-4),
+			CLONE_FILES|SIG_THREAD_EXIT|CLONE_VM,th);
+
+    if(th && kid_pid>0) {
+	link_thread(th,kid_pid);
+	return th->pid;
+    } else {
+	destroy_thread(th);
+	return 0;
+    }
+}
+#endif
+
 void destroy_thread (struct thread *th)
 {
     /* precondition: the unix task has already been killed and exited.
@@ -230,14 +238,13 @@ 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--;
     th->state=STATE_STOPPED;
     if(th==all_threads) 
 	all_threads=th->next;
     else {
 	struct thread *th1=all_threads;
-	while(th1->next!=th) th1=th1->next;
-	th1->next=th->next;	/* unlink */
+	while(th1 && th1->next!=th) th1=th1->next;
+	if(th1)	th1->next=th->next;	/* unlink */
     }
     release_spinlock(&all_threads_lock);
     if(th && th->tls_cookie>=0) arch_os_thread_cleanup(th); 
@@ -302,8 +309,6 @@ int signal_thread_to_dequeue (pid_t pid)
  * all the others with SIG_STOP_FOR_GC.  The handler for this thread does
  * the usual pseudo-atomic checks (we don't want to stop a thread while 
  * it's in the middle of allocation) then kills _itself_ with SIGSTOP.
- * At any given time, countdown_to_gc should reflect the number of threads
- * signalled but which haven't yet come to rest
  */
 
 void gc_stop_the_world()
@@ -317,15 +322,7 @@ void gc_stop_the_world()
 	for(p=all_threads,old_pid=p->pid; p; p=p->next) {
 	    if(p==th) continue;
 	    if(p->state!=STATE_RUNNING) continue;
-	    countdown_to_gc++;
 	    p->state=STATE_STOPPING;
-	    /* Note no return value check from kill().  If the
-	     * thread had been reaped already, we kill it and
-	     * increment countdown_to_gc anyway.  This is to avoid
-	     * complicating the logic in destroy_thread, which would 
-	     * otherwise have to know whether the thread died before or
-	     * after it was killed
-	     */
 	    kill(p->pid,SIG_STOP_FOR_GC);
 	}
 	release_spinlock(&all_threads_lock);

version.lisp-expr

@@ -17,4 +17,4 @@
 ;;; checkins which aren't released. (And occasionally for internal
 ;;; versions, especially for internal versions off the main CVS
 ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
-"0.8.6.37"
+"0.8.6.38"