Merge commit 'b9b88351ea2c4b43a6f90938554dc5693b17e328'

[bpt/guile.git] / libguile / finalizers.c

diff --git a/libguile/finalizers.c b/libguile/finalizers.c
index 42faf72..eaea139 100644 (file)
--- a/libguile/finalizers.c
+++ b/libguile/finalizers.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2012 Free Software Foundation, Inc.
+/* Copyright (C) 2012, 2013 Free Software Foundation, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -43,17 +43,6 @@ static size_t finalization_count;
 
 \f
 
-#ifndef HAVE_GC_SET_FINALIZER_NOTIFIER
-static void
-GC_set_finalizer_notifier (void (*notifier) (void))
-{
-  GC_finalizer_notifier = notifier;
-}
-#endif
-
-
-\f
-
 void
 scm_i_set_finalizer (void *obj, scm_t_finalizer_proc proc, void *data)
 {
@@ -185,6 +174,7 @@ static int finalization_pipe[2];
 static scm_i_pthread_mutex_t finalization_thread_lock =
   SCM_I_PTHREAD_MUTEX_INITIALIZER;
 static pthread_t finalization_thread;
+static int finalization_thread_is_running = 0;
 
 static void
 notify_finalizers_to_run (void)
@@ -256,14 +246,18 @@ static void
 start_finalization_thread (void)
 {
   scm_i_pthread_mutex_lock (&finalization_thread_lock);
-  if (!finalization_thread)
-    /* Use the raw pthread API and scm_with_guile, because we don't want
-       to block on any lock that scm_spawn_thread might want to take,
-       and we don't want to inherit the dynamic state (fluids) of the
-       caller.  */
-    if (pthread_create (&finalization_thread, NULL,
-                        run_finalization_thread, NULL))
-      perror ("error creating finalization thread");
+  if (!finalization_thread_is_running)
+    {
+      /* Use the raw pthread API and scm_with_guile, because we don't want
+        to block on any lock that scm_spawn_thread might want to take,
+        and we don't want to inherit the dynamic state (fluids) of the
+        caller.  */
+      if (pthread_create (&finalization_thread, NULL,
+                         run_finalization_thread, NULL))
+       perror ("error creating finalization thread");
+      else
+       finalization_thread_is_running = 1;
+    }
   scm_i_pthread_mutex_unlock (&finalization_thread_lock);
 }
 
@@ -271,12 +265,12 @@ static void
 stop_finalization_thread (void)
 {
   scm_i_pthread_mutex_lock (&finalization_thread_lock);
-  if (finalization_thread)
+  if (finalization_thread_is_running)
     {
       notify_about_to_fork ();
       if (pthread_join (finalization_thread, NULL))
         perror ("joining finalization thread");
-      finalization_thread = 0;
+      finalization_thread_is_running = 0;
     }
   scm_i_pthread_mutex_unlock (&finalization_thread_lock);
 }
@@ -305,6 +299,64 @@ scm_i_finalizer_pre_fork (void)
 
 \f
 
+static void*
+weak_pointer_ref (void *weak_pointer) 
+{
+  return *(void **) weak_pointer;
+}
+
+static void
+weak_gc_finalizer (void *ptr, void *data)
+{
+  void **weak = ptr;
+  void *val;
+  void (*callback) (SCM) = weak[1];
+
+  val = GC_call_with_alloc_lock (weak_pointer_ref, &weak[0]);
+
+  if (!val)
+    return;
+
+  callback (SCM_PACK_POINTER (val));
+
+  scm_i_set_finalizer (ptr, weak_gc_finalizer, data);
+}
+
+/* CALLBACK will be called on OBJ, as long as OBJ is accessible.  It
+   will be called from a finalizer, which may be from an async or from
+   another thread.
+
+   As an implementation detail, the way this works is that we allocate
+   a fresh pointer-less object holding two words.  We know that this
+   object should get collected the next time GC is run, so we attach a
+   finalizer to it so that we get a callback after GC happens.
+
+   The first word of the object holds a weak reference to OBJ, and the
+   second holds the callback pointer.  When the callback is called, we
+   check if the weak reference on OBJ still holds.  If it doesn't hold,
+   then OBJ is no longer accessible, and we're done.  Otherwise we call
+   the callback and re-register a finalizer for our two-word GC object,
+   effectively resuscitating the object so that we will get a callback
+   on the next GC.
+
+   We could use the scm_after_gc_hook, but using a finalizer has the
+   advantage of potentially running in another thread, decreasing pause
+   time.  */
+void
+scm_i_register_weak_gc_callback (SCM obj, void (*callback) (SCM))
+{
+  void **weak = GC_MALLOC_ATOMIC (sizeof (void*) * 2);
+
+  weak[0] = SCM_UNPACK_POINTER (obj);
+  weak[1] = (void*)callback;
+  GC_GENERAL_REGISTER_DISAPPEARING_LINK (weak, SCM2PTR (obj));
+
+  scm_i_set_finalizer (weak, weak_gc_finalizer, NULL);
+}
+
+
+\f
+
 void
 scm_init_finalizers (void)
 {