libguile/guardians.c

   1 /* Copyright (C) 1998,1999,2000,2001, 2006, 2008 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
  20 /* This is an implementation of guardians as described in
  21  * R. Kent Dybvig, Carl Bruggeman, and David Eby (1993) "Guardians in
  22  * a Generation-Based Garbage Collector" ACM SIGPLAN Conference on
  23  * Programming Language Design and Implementation, June 1993
  24  * ftp://ftp.cs.indiana.edu/pub/scheme-repository/doc/pubs/guardians.ps.gz
  25  *
  26  * Original design:          Mikael Djurfeldt
  27  * Original implementation:  Michael Livshin
  28  * Hacked on since by:       everybody
  29  *
  30  * By this point, the semantics are actually quite different from
  31  * those described in the abovementioned paper.  The semantic changes
  32  * are there to improve safety and intuitiveness.  The interface is
  33  * still (mostly) the one described by the paper, however.
  34  *
  35  * Boiled down again:        Marius Vollmer
  36  *
  37  * Now they should again behave like those described in the paper.
  38  * Scheme guardians should be simple and friendly, not like the greedy
  39  * monsters we had...
  40  */
  41
  42 #ifdef HAVE_CONFIG_H
  43 # include <config.h>
  44 #endif
  45
  46 #include "libguile/_scm.h"
  47 #include "libguile/async.h"
  48 #include "libguile/ports.h"
  49 #include "libguile/print.h"
  50 #include "libguile/smob.h"
  51 #include "libguile/validate.h"
  52 #include "libguile/root.h"
  53 #include "libguile/hashtab.h"
  54 #include "libguile/weaks.h"
  55 #include "libguile/deprecation.h"
  56 #include "libguile/eval.h"
  57
  58 #include "libguile/guardians.h"
  59
  60
  61 /* The live and zombies FIFOs are implemented as tconcs as described
  62    in Dybvig's paper.  This decouples addition and removal of elements
  63    so that no synchronization between these needs to take place.
  64 */
  65
  66 typedef struct t_tconc
  67 {
  68   SCM head;
  69   SCM tail;
  70 } t_tconc;
  71
  72 #define TCONC_EMPTYP(tc) (scm_is_eq ((tc).head, (tc).tail))
  73
  74 #define TCONC_IN(tc, obj, pair) \
  75 do { \
  76   SCM_SETCAR ((tc).tail, obj); \
  77   SCM_SET_CELL_OBJECT_1 (pair, SCM_EOL); \
  78   SCM_SET_CELL_OBJECT_0 (pair, SCM_BOOL_F); \
  79   SCM_SETCDR ((tc).tail, pair); \
  80   (tc).tail = pair; \
  81 } while (0)
  82
  83 #define TCONC_OUT(tc, res) \
  84 do { \
  85   (res) = SCM_CAR ((tc).head); \
  86   (tc).head = SCM_CDR ((tc).head); \
  87 } while (0)
  88
  89
  90 static scm_t_bits tc16_guardian;
  91
  92 typedef struct t_guardian
  93 {
  94   t_tconc live;
  95   t_tconc zombies;
  96   struct t_guardian *next;
  97 } t_guardian;
  98
  99 #define GUARDIAN_P(x)    SCM_SMOB_PREDICATE(tc16_guardian, x)
 100 #define GUARDIAN_DATA(x) ((t_guardian *) SCM_CELL_WORD_1 (x))
 101
 102 static t_guardian *guardians;
 103
 104 void
 105 scm_i_init_guardians_for_gc ()
 106 {
 107   guardians = NULL;
 108 }
 109
 110 /* mark a guardian by adding it to the live guardian list.  */
 111 static SCM
 112 guardian_mark (SCM ptr)
 113 {
 114   t_guardian *g = GUARDIAN_DATA (ptr);
 115   g->next = guardians;
 116   guardians = g;
 117
 118   return SCM_BOOL_F;
 119 }
 120
 121 /* Identify inaccessible objects and move them from the live list to
 122    the zombie list.  An object is inaccessible when it is unmarked at
 123    this point.  Therefore, the inaccessible objects are not marked yet
 124    since that would prevent them from being recognized as
 125    inaccessible.
 126
 127    The pairs that form the life list itself are marked, tho.
 128 */
 129 void
 130 scm_i_identify_inaccessible_guardeds ()
 131 {
 132   t_guardian *g;
 133
 134   for (g = guardians; g; g = g->next)
 135     {
 136       SCM pair, next_pair;
 137       SCM *prev_ptr;
 138
 139       for (pair = g->live.head, prev_ptr = &g->live.head;
 140            !scm_is_eq (pair, g->live.tail);
 141            pair = next_pair)
 142         {
 143           SCM obj = SCM_CAR (pair);
 144           next_pair = SCM_CDR (pair);
 145           if (!SCM_GC_MARK_P (obj))
 146             {
 147               /* Unmarked, move to 'inaccessible' list.
 148                */
 149               *prev_ptr = next_pair;
 150               TCONC_IN (g->zombies, obj, pair);
 151             }
 152           else
 153             {
 154               SCM_SET_GC_MARK (pair);
 155               prev_ptr = SCM_CDRLOC (pair);
 156             }
 157         }
 158       SCM_SET_GC_MARK (pair);
 159     }
 160 }
 161
 162 int
 163 scm_i_mark_inaccessible_guardeds ()
 164 {
 165   t_guardian *g;
 166   int again = 0;
 167
 168   /* We never need to see the guardians again that are processed here,
 169      so we clear the list.  Calling scm_gc_mark below might find new
 170      guardians, however (and other things), and we inform the GC about
 171      this by returning non-zero.  See scm_mark_all in gc-mark.c
 172   */
 173
 174   g = guardians;
 175   guardians = NULL;
 176
 177   for (; g; g = g->next)
 178     {
 179       SCM pair;
 180
 181       for (pair = g->zombies.head;
 182            !scm_is_eq (pair, g->zombies.tail);
 183            pair = SCM_CDR (pair))
 184         {
 185           if (!SCM_GC_MARK_P (pair))
 186             {
 187               scm_gc_mark (SCM_CAR (pair));
 188               SCM_SET_GC_MARK (pair);
 189               again = 1;
 190             }
 191         }
 192       SCM_SET_GC_MARK (pair);
 193     }
 194   return again;
 195 }
 196
 197 static size_t
 198 guardian_free (SCM ptr)
 199 {
 200   scm_gc_free (GUARDIAN_DATA (ptr), sizeof (t_guardian), "guardian");
 201   return 0;
 202 }
 203
 204 static int
 205 guardian_print (SCM guardian, SCM port, scm_print_state *pstate SCM_UNUSED)
 206 {
 207   t_guardian *g = GUARDIAN_DATA (guardian);
 208
 209   scm_puts ("#<guardian ", port);
 210   scm_uintprint ((scm_t_bits) g, 16, port);
 211
 212   scm_puts (" (reachable: ", port);
 213   scm_display (scm_length (SCM_CDR (g->live.head)), port);
 214   scm_puts (" unreachable: ", port);
 215   scm_display (scm_length (SCM_CDR (g->zombies.head)), port);
 216   scm_puts (")", port);
 217
 218   scm_puts (">", port);
 219
 220   return 1;
 221 }
 222
 223 static void
 224 scm_i_guard (SCM guardian, SCM obj)
 225 {
 226   t_guardian *g = GUARDIAN_DATA (guardian);
 227
 228   if (!SCM_IMP (obj))
 229     {
 230       SCM z;
 231       z = scm_cons (SCM_BOOL_F, SCM_BOOL_F);
 232       TCONC_IN (g->live, obj, z);
 233     }
 234 }
 235
 236 static SCM
 237 scm_i_get_one_zombie (SCM guardian)
 238 {
 239   t_guardian *g = GUARDIAN_DATA (guardian);
 240   SCM res = SCM_BOOL_F;
 241
 242   if (!TCONC_EMPTYP (g->zombies))
 243     TCONC_OUT (g->zombies, res);
 244
 245   return res;
 246 }
 247
 248 /* This is the Scheme entry point for each guardian: If OBJ is an
 249  * object, it's added to the guardian's live list.  If OBJ is unbound,
 250  * the next available unreachable object (or #f if none) is returned.
 251  *
 252  * If the second optional argument THROW_P is true (the default), then
 253  * an error is raised if GUARDIAN is greedy and OBJ is already greedily
 254  * guarded.  If THROW_P is false, #f is returned instead of raising the
 255  * error, and #t is returned if everything is fine.
 256  */
 257 static SCM
 258 guardian_apply (SCM guardian, SCM obj, SCM throw_p)
 259 {
 260 #if ENABLE_DEPRECATED
 261   if (!SCM_UNBNDP (throw_p))
 262     scm_c_issue_deprecation_warning
 263       ("Using the 'throw?' argument of a guardian is deprecated "
 264        "and ineffective.");
 265 #endif
 266
 267   if (!SCM_UNBNDP (obj))
 268     {
 269       scm_i_guard (guardian, obj);
 270       return SCM_UNSPECIFIED;
 271     }
 272   else
 273     return scm_i_get_one_zombie (guardian);
 274 }
 275
 276 SCM_DEFINE (scm_make_guardian, "make-guardian", 0, 0, 0,
 277             (),
 278 "Create a new guardian.  A guardian protects a set of objects from\n"
 279 "garbage collection, allowing a program to apply cleanup or other\n"
 280 "actions.\n"
 281 "\n"
 282 "@code{make-guardian} returns a procedure representing the guardian.\n"
 283 "Calling the guardian procedure with an argument adds the argument to\n"
 284 "the guardian's set of protected objects.  Calling the guardian\n"
 285 "procedure without an argument returns one of the protected objects\n"
 286 "which are ready for garbage collection, or @code{#f} if no such object\n"
 287 "is available.  Objects which are returned in this way are removed from\n"
 288 "the guardian.\n"
 289 "\n"
 290 "You can put a single object into a guardian more than once and you can\n"
 291 "put a single object into more than one guardian.  The object will then\n"
 292 "be returned multiple times by the guardian procedures.\n"
 293 "\n"
 294 "An object is eligible to be returned from a guardian when it is no\n"
 295 "longer referenced from outside any guardian.\n"
 296 "\n"
 297 "There is no guarantee about the order in which objects are returned\n"
 298 "from a guardian.  If you want to impose an order on finalization\n"
 299 "actions, for example, you can do that by keeping objects alive in some\n"
 300 "global data structure until they are no longer needed for finalizing\n"
 301 "other objects.\n"
 302 "\n"
 303 "Being an element in a weak vector, a key in a hash table with weak\n"
 304 "keys, or a value in a hash table with weak value does not prevent an\n"
 305 "object from being returned by a guardian.  But as long as an object\n"
 306 "can be returned from a guardian it will not be removed from such a\n"
 307 "weak vector or hash table.  In other words, a weak link does not\n"
 308 "prevent an object from being considered collectable, but being inside\n"
 309 "a guardian prevents a weak link from being broken.\n"
 310 "\n"
 311 "A key in a weak key hash table can be though of as having a strong\n"
 312 "reference to its associated value as long as the key is accessible.\n"
 313 "Consequently, when the key only accessible from within a guardian, the\n"
 314 "reference from the key to the value is also considered to be coming\n"
 315 "from within a guardian.  Thus, if there is no other reference to the\n"
 316             "value, it is eligible to be returned from a guardian.\n")
 317 #define FUNC_NAME s_scm_make_guardian
 318 {
 319   t_guardian *g = scm_gc_malloc (sizeof (t_guardian), "guardian");
 320   SCM z1 = scm_cons (SCM_BOOL_F, SCM_EOL);
 321   SCM z2 = scm_cons (SCM_BOOL_F, SCM_EOL);
 322   SCM z;
 323
 324   /* A tconc starts out with one tail pair. */
 325   g->live.head = g->live.tail = z1;
 326   g->zombies.head = g->zombies.tail = z2;
 327
 328   g->next = NULL;
 329
 330   SCM_NEWSMOB (z, tc16_guardian, g);
 331
 332   return z;
 333 }
 334 #undef FUNC_NAME
 335
 336 void
 337 scm_init_guardians ()
 338 {
 339   tc16_guardian = scm_make_smob_type ("guardian", 0);
 340   scm_set_smob_mark (tc16_guardian, guardian_mark);
 341   scm_set_smob_free (tc16_guardian, guardian_free);
 342   scm_set_smob_print (tc16_guardian, guardian_print);
 343 #if ENABLE_DEPRECATED
 344   scm_set_smob_apply (tc16_guardian, guardian_apply, 0, 2, 0);
 345 #else
 346   scm_set_smob_apply (tc16_guardian, guardian_apply, 0, 1, 0);
 347 #endif
 348
 349 #include "libguile/guardians.x"
 350 }
 351
 352 /*
 353   Local Variables:
 354   c-file-style: "gnu"
 355   End:
 356 */