1 /* Copyright (C) 1998,1999,2000,2001, 2006, 2008 Free Software Foundation, Inc.
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.
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.
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
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
26 * Original design: Mikael Djurfeldt
27 * Original implementation: Michael Livshin
28 * Hacked on since by: everybody
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.
35 * Boiled down again: Marius Vollmer
37 * Now they should again behave like those described in the paper.
38 * Scheme guardians should be simple and friendly, not like the greedy
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"
58 #include "libguile/guardians.h"
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.
66 typedef struct t_tconc
72 #define TCONC_EMPTYP(tc) (scm_is_eq ((tc).head, (tc).tail))
74 #define TCONC_IN(tc, obj, pair) \
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); \
83 #define TCONC_OUT(tc, res) \
85 (res) = SCM_CAR ((tc).head); \
86 (tc).head = SCM_CDR ((tc).head); \
90 static scm_t_bits tc16_guardian
;
92 typedef struct t_guardian
96 struct t_guardian
*next
;
99 #define GUARDIAN_P(x) SCM_SMOB_PREDICATE(tc16_guardian, x)
100 #define GUARDIAN_DATA(x) ((t_guardian *) SCM_CELL_WORD_1 (x))
102 static t_guardian
*guardians
;
105 scm_i_init_guardians_for_gc ()
110 /* mark a guardian by adding it to the live guardian list. */
112 guardian_mark (SCM ptr
)
114 t_guardian
*g
= GUARDIAN_DATA (ptr
);
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
127 The pairs that form the life list itself are marked, tho.
130 scm_i_identify_inaccessible_guardeds ()
134 for (g
= guardians
; g
; g
= g
->next
)
139 for (pair
= g
->live
.head
, prev_ptr
= &g
->live
.head
;
140 !scm_is_eq (pair
, g
->live
.tail
);
143 SCM obj
= SCM_CAR (pair
);
144 next_pair
= SCM_CDR (pair
);
145 if (!SCM_GC_MARK_P (obj
))
147 /* Unmarked, move to 'inaccessible' list.
149 *prev_ptr
= next_pair
;
150 TCONC_IN (g
->zombies
, obj
, pair
);
154 SCM_SET_GC_MARK (pair
);
155 prev_ptr
= SCM_CDRLOC (pair
);
158 SCM_SET_GC_MARK (pair
);
163 scm_i_mark_inaccessible_guardeds ()
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
177 for (; g
; g
= g
->next
)
181 for (pair
= g
->zombies
.head
;
182 !scm_is_eq (pair
, g
->zombies
.tail
);
183 pair
= SCM_CDR (pair
))
185 if (!SCM_GC_MARK_P (pair
))
187 scm_gc_mark (SCM_CAR (pair
));
188 SCM_SET_GC_MARK (pair
);
192 SCM_SET_GC_MARK (pair
);
198 guardian_free (SCM ptr
)
200 scm_gc_free (GUARDIAN_DATA (ptr
), sizeof (t_guardian
), "guardian");
205 guardian_print (SCM guardian
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
207 t_guardian
*g
= GUARDIAN_DATA (guardian
);
209 scm_puts ("#<guardian ", port
);
210 scm_uintprint ((scm_t_bits
) g
, 16, port
);
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
);
218 scm_puts (">", port
);
224 scm_i_guard (SCM guardian
, SCM obj
)
226 t_guardian
*g
= GUARDIAN_DATA (guardian
);
231 z
= scm_cons (SCM_BOOL_F
, SCM_BOOL_F
);
232 TCONC_IN (g
->live
, obj
, z
);
237 scm_i_get_one_zombie (SCM guardian
)
239 t_guardian
*g
= GUARDIAN_DATA (guardian
);
240 SCM res
= SCM_BOOL_F
;
242 if (!TCONC_EMPTYP (g
->zombies
))
243 TCONC_OUT (g
->zombies
, res
);
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.
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.
258 guardian_apply (SCM guardian
, SCM obj
, SCM throw_p
)
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 "
267 if (!SCM_UNBNDP (obj
))
269 scm_i_guard (guardian
, obj
);
270 return SCM_UNSPECIFIED
;
273 return scm_i_get_one_zombie (guardian
);
276 SCM_DEFINE (scm_make_guardian
, "make-guardian", 0, 0, 0,
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"
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"
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"
294 "An object is eligible to be returned from a guardian when it is no\n"
295 "longer referenced from outside any guardian.\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"
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"
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
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
);
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
;
330 SCM_NEWSMOB (z
, tc16_guardian
, g
);
337 scm_init_guardians ()
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);
346 scm_set_smob_apply (tc16_guardian
, guardian_apply
, 0, 1, 0);
349 #include "libguile/guardians.x"