libguile/guardians.c

   1 /* Copyright (C) 1998,1999,2000,2001, 2006 Free Software Foundation, Inc.
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public
   5  * License as published by the Free Software Foundation; either
   6  * version 2.1 of the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  16  */
  17
  18 \f
  19 /* This is an implementation of guardians as described in
  20  * R. Kent Dybvig, Carl Bruggeman, and David Eby (1993) "Guardians in
  21  * a Generation-Based Garbage Collector" ACM SIGPLAN Conference on
  22  * Programming Language Design and Implementation, June 1993
  23  * ftp://ftp.cs.indiana.edu/pub/scheme-repository/doc/pubs/guardians.ps.gz
  24  *
  25  * Original design:          Mikael Djurfeldt
  26  * Original implementation:  Michael Livshin
  27  * Hacked on since by:       everybody
  28  *
  29  * By this point, the semantics are actually quite different from
  30  * those described in the abovementioned paper.  The semantic changes
  31  * are there to improve safety and intuitiveness.  The interface is
  32  * still (mostly) the one described by the paper, however.
  33  *
  34  * Boiled down again:        Marius Vollmer
  35  *
  36  * Now they should again behave like those described in the paper.
  37  * Scheme guardians should be simple and friendly, not like the greedy
  38  * monsters we had...
  39  *
  40  * Rewritten for the Boehm-Wiser GC by Ludovic Courtès.
  41  * FIXME: This is currently not thread-safe.
  42  */
  43
  44
  45 #include "libguile/_scm.h"
  46 #include "libguile/async.h"
  47 #include "libguile/ports.h"
  48 #include "libguile/print.h"
  49 #include "libguile/smob.h"
  50 #include "libguile/validate.h"
  51 #include "libguile/root.h"
  52 #include "libguile/hashtab.h"
  53 #include "libguile/weaks.h"
  54 #include "libguile/deprecation.h"
  55 #include "libguile/eval.h"
  56
  57 #include "libguile/guardians.h"
  58 #include "libguile/boehm-gc.h"
  59
  60
  61
  62
  63 static scm_t_bits tc16_guardian;
  64
  65 typedef struct t_guardian
  66 {
  67   unsigned long live;
  68   SCM zombies;
  69   struct t_guardian *next;
  70 } t_guardian;
  71
  72 #define GUARDIAN_P(x)    SCM_SMOB_PREDICATE(tc16_guardian, x)
  73 #define GUARDIAN_DATA(x) ((t_guardian *) SCM_CELL_WORD_1 (x))
  74
  75
  76
  77
  78 static int
  79 guardian_print (SCM guardian, SCM port, scm_print_state *pstate SCM_UNUSED)
  80 {
  81   t_guardian *g = GUARDIAN_DATA (guardian);
  82
  83   scm_puts ("#<guardian ", port);
  84   scm_uintprint ((scm_t_bits) g, 16, port);
  85
  86   scm_puts (" (reachable: ", port);
  87   scm_display (scm_from_uint (g->live), port);
  88   scm_puts (" unreachable: ", port);
  89   scm_display (scm_length (g->zombies), port);
  90   scm_puts (")", port);
  91
  92   scm_puts (">", port);
  93
  94   return 1;
  95 }
  96
  97 /* Handle finalization of OBJ which is guarded by the guardians listed in
  98    GUARDIAN_LIST.  */
  99 static void
 100 finalize_guarded (GC_PTR ptr, GC_PTR finalizer_data)
 101 {
 102   SCM cell_pool;
 103   SCM obj, guardian_list, proxied_finalizer;
 104
 105   obj = PTR2SCM (ptr);
 106   guardian_list = SCM_CDR (PTR2SCM (finalizer_data));
 107   proxied_finalizer = SCM_CAR (PTR2SCM (finalizer_data));
 108
 109 #if 0
 110   printf ("finalizing guarded %p (%u guardians)\n",
 111           ptr, scm_to_uint (scm_length (guardian_list)));
 112 #endif
 113
 114   /* Preallocate a bunch of cells so that we can make sure that no garbage
 115      collection (and, thus, nested calls to `finalize_guarded ()') occurs
 116      while executing the following loop.  This is quite inefficient (call to
 117      `scm_length ()') but that shouldn't be a problem in most cases.  */
 118   cell_pool = scm_make_list (scm_length (guardian_list), SCM_UNSPECIFIED);
 119
 120   /* Tell each guardian interested in OBJ that OBJ is no longer
 121      reachable.  */
 122   for (;
 123        guardian_list != SCM_EOL;
 124        guardian_list = SCM_CDR (guardian_list))
 125     {
 126       SCM zombies;
 127       t_guardian *g;
 128
 129       if (SCM_WEAK_PAIR_CAR_DELETED_P (guardian_list))
 130         /* The guardian itself vanished in the meantime.  */
 131         continue;
 132
 133       g = GUARDIAN_DATA (SCM_CAR (guardian_list));
 134       if (g->live == 0)
 135         abort ();
 136
 137       /* Get a fresh cell from CELL_POOL.  */
 138       zombies = cell_pool;
 139       cell_pool = SCM_CDR (cell_pool);
 140
 141       /* Compute and update G's zombie list.  */
 142       SCM_SETCAR (zombies, SCM_PACK (obj));
 143       SCM_SETCDR (zombies, g->zombies);
 144       g->zombies = zombies;
 145
 146       g->live--;
 147       g->zombies = zombies;
 148     }
 149
 150   if (proxied_finalizer != SCM_BOOL_F)
 151     {
 152       /* Re-register the finalizer that was in place before we installed this
 153          one.  */
 154       GC_finalization_proc finalizer, prev_finalizer;
 155       GC_PTR finalizer_data, prev_finalizer_data;
 156
 157       finalizer = (GC_finalization_proc) SCM2PTR (SCM_CAR (proxied_finalizer));
 158       finalizer_data = SCM2PTR (SCM_CDR (proxied_finalizer));
 159
 160       if (finalizer == NULL)
 161         abort ();
 162
 163       GC_REGISTER_FINALIZER_NO_ORDER (ptr, finalizer, finalizer_data,
 164                                       &prev_finalizer, &prev_finalizer_data);
 165
 166 #if 0
 167       printf ("  reinstalled proxied finalizer %p for %p\n", finalizer, ptr);
 168 #endif
 169     }
 170
 171 #if 0
 172   printf ("end of finalize (%p)\n", ptr);
 173 #endif
 174 }
 175
 176 /* Add OBJ as a guarded object of GUARDIAN.  */
 177 static void
 178 scm_i_guard (SCM guardian, SCM obj)
 179 {
 180   t_guardian *g = GUARDIAN_DATA (guardian);
 181
 182   if (SCM_NIMP (obj))
 183     {
 184       /* Register a finalizer and pass a pair as the ``client data''
 185          argument.  The pair contains in its car `#f' or a pair describing a
 186          ``proxied'' finalizer (see below); its cdr contains a list of
 187          guardians interested in OBJ.
 188
 189          A ``proxied'' finalizer is a finalizer that was registered for OBJ
 190          before OBJ became guarded (e.g., a SMOB `free' function).  We are
 191          assuming here that finalizers are only used internally, either at
 192          the very beginning of an object's lifetime (e.g., see `SCM_NEWSMOB')
 193          or by this function.  */
 194       GC_finalization_proc prev_finalizer;
 195       GC_PTR prev_data;
 196       SCM guardians_for_obj, finalizer_data;
 197
 198       g->live++;
 199
 200       /* Note: GUARDIANS_FOR_OBJ is a weak list so that a guardian can be
 201          collected before the objects it guards (see `guardians.test').  */
 202       guardians_for_obj = scm_weak_car_pair (guardian, SCM_EOL);
 203       finalizer_data = scm_cons (SCM_BOOL_F, guardians_for_obj);
 204
 205       GC_REGISTER_FINALIZER_NO_ORDER (SCM2PTR (obj), finalize_guarded,
 206                                       SCM2PTR (finalizer_data),
 207                                       &prev_finalizer, &prev_data);
 208
 209       if (prev_finalizer == finalize_guarded)
 210         {
 211           /* OBJ is already guarded by another guardian: add GUARDIAN to its
 212              list of guardians.  */
 213           SCM prev_guardian_list, prev_finalizer_data;
 214
 215           if (prev_data == NULL)
 216             abort ();
 217
 218           prev_finalizer_data = PTR2SCM (prev_data);
 219           if (!scm_is_pair (prev_finalizer_data))
 220             abort ();
 221
 222           prev_guardian_list = SCM_CDR (prev_finalizer_data);
 223           SCM_SETCDR (guardians_for_obj, prev_guardian_list);
 224
 225           /* Also copy information about proxied finalizers.  */
 226           SCM_SETCAR (finalizer_data, SCM_CAR (prev_finalizer_data));
 227         }
 228       else if (prev_finalizer != NULL)
 229         {
 230           /* There was already a finalizer registered for OBJ so we will
 231              ``proxy'' it, i.e., record it so that we can re-register it once
 232              `finalize_guarded ()' has finished.  */
 233           SCM proxied_finalizer;
 234
 235           proxied_finalizer = scm_cons (PTR2SCM (prev_finalizer),
 236                                         PTR2SCM (prev_data));
 237           SCM_SETCAR (finalizer_data, proxied_finalizer);
 238         }
 239     }
 240 }
 241
 242 static SCM
 243 scm_i_get_one_zombie (SCM guardian)
 244 {
 245   t_guardian *g = GUARDIAN_DATA (guardian);
 246   SCM res = SCM_BOOL_F;
 247
 248   if (g->zombies != SCM_EOL)
 249     {
 250       /* Note: We return zombies in reverse order.  */
 251       res = SCM_CAR (g->zombies);
 252       g->zombies = SCM_CDR (g->zombies);
 253     }
 254
 255   return res;
 256 }
 257
 258 /* This is the Scheme entry point for each guardian: If OBJ is an
 259  * object, it's added to the guardian's live list.  If OBJ is unbound,
 260  * the next available unreachable object (or #f if none) is returned.
 261  *
 262  * If the second optional argument THROW_P is true (the default), then
 263  * an error is raised if GUARDIAN is greedy and OBJ is already greedily
 264  * guarded.  If THROW_P is false, #f is returned instead of raising the
 265  * error, and #t is returned if everything is fine.
 266  */
 267 static SCM
 268 guardian_apply (SCM guardian, SCM obj, SCM throw_p)
 269 {
 270 #if ENABLE_DEPRECATED
 271   if (!SCM_UNBNDP (throw_p))
 272     scm_c_issue_deprecation_warning
 273       ("Using the 'throw?' argument of a guardian is deprecated "
 274        "and ineffective.");
 275 #endif
 276
 277   if (!SCM_UNBNDP (obj))
 278     {
 279       scm_i_guard (guardian, obj);
 280       return SCM_UNSPECIFIED;
 281     }
 282   else
 283     return scm_i_get_one_zombie (guardian);
 284 }
 285
 286 SCM_DEFINE (scm_make_guardian, "make-guardian", 0, 0, 0,
 287             (),
 288 "Create a new guardian.  A guardian protects a set of objects from\n"
 289 "garbage collection, allowing a program to apply cleanup or other\n"
 290 "actions.\n"
 291 "\n"
 292 "@code{make-guardian} returns a procedure representing the guardian.\n"
 293 "Calling the guardian procedure with an argument adds the argument to\n"
 294 "the guardian's set of protected objects.  Calling the guardian\n"
 295 "procedure without an argument returns one of the protected objects\n"
 296 "which are ready for garbage collection, or @code{#f} if no such object\n"
 297 "is available.  Objects which are returned in this way are removed from\n"
 298 "the guardian.\n"
 299 "\n"
 300 "You can put a single object into a guardian more than once and you can\n"
 301 "put a single object into more than one guardian.  The object will then\n"
 302 "be returned multiple times by the guardian procedures.\n"
 303 "\n"
 304 "An object is eligible to be returned from a guardian when it is no\n"
 305 "longer referenced from outside any guardian.\n"
 306 "\n"
 307 "There is no guarantee about the order in which objects are returned\n"
 308 "from a guardian.  If you want to impose an order on finalization\n"
 309 "actions, for example, you can do that by keeping objects alive in some\n"
 310 "global data structure until they are no longer needed for finalizing\n"
 311 "other objects.\n"
 312 "\n"
 313 "Being an element in a weak vector, a key in a hash table with weak\n"
 314 "keys, or a value in a hash table with weak value does not prevent an\n"
 315 "object from being returned by a guardian.  But as long as an object\n"
 316 "can be returned from a guardian it will not be removed from such a\n"
 317 "weak vector or hash table.  In other words, a weak link does not\n"
 318 "prevent an object from being considered collectable, but being inside\n"
 319 "a guardian prevents a weak link from being broken.\n"
 320 "\n"
 321 "A key in a weak key hash table can be though of as having a strong\n"
 322 "reference to its associated value as long as the key is accessible.\n"
 323 "Consequently, when the key only accessible from within a guardian, the\n"
 324 "reference from the key to the value is also considered to be coming\n"
 325 "from within a guardian.  Thus, if there is no other reference to the\n"
 326             "value, it is eligible to be returned from a guardian.\n")
 327 #define FUNC_NAME s_scm_make_guardian
 328 {
 329   t_guardian *g = scm_gc_malloc (sizeof (t_guardian), "guardian");
 330   SCM z;
 331
 332   /* A tconc starts out with one tail pair. */
 333   g->live = 0;
 334   g->zombies = SCM_EOL;
 335
 336   g->next = NULL;
 337
 338   SCM_NEWSMOB (z, tc16_guardian, g);
 339
 340   return z;
 341 }
 342 #undef FUNC_NAME
 343
 344 void
 345 scm_init_guardians ()
 346 {
 347   /* We use unordered finalization `a la Java.  */
 348   GC_java_finalization = 1;
 349
 350   tc16_guardian = scm_make_smob_type ("guardian", 0);
 351
 352   scm_set_smob_print (tc16_guardian, guardian_print);
 353 #if ENABLE_DEPRECATED
 354   scm_set_smob_apply (tc16_guardian, guardian_apply, 0, 2, 0);
 355 #else
 356   scm_set_smob_apply (tc16_guardian, guardian_apply, 0, 1, 0);
 357 #endif
 358
 359 #include "libguile/guardians.x"
 360 }
 361
 362 /*
 363   Local Variables:
 364   c-file-style: "gnu"
 365   End:
 366 */