2 * Copyright (c) 2001 by Hewlett-Packard Company. All rights reserved.
4 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
5 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
7 * Permission is hereby granted to use or copy this program
8 * for any purpose, provided the above notices are retained on all copies.
9 * Permission to modify the code and to distribute modified code is granted,
10 * provided the above notices are retained, and a notice that the code was
11 * modified is included with the above copyright notice.
16 * This implements a full, though not well-tuned, representation of the
17 * backwards points-to graph. This is used to test for non-GC-robust
18 * data structures; the code is not used during normal garbage collection.
20 * One restriction is that we drop all back-edges from nodes with very
21 * high in-degree, and simply add them add them to a list of such
22 * nodes. They are then treated as permanent roots. Id this by itself
23 * doesn't introduce a space leak, then such nodes can't contribute to
24 * a growing space leak.
29 #ifdef MAKE_BACK_GRAPH
31 #define MAX_IN 10 /* Maximum in-degree we handle directly */
33 #include "private/dbg_mlc.h"
36 #if !defined(DBG_HDRS_ALL) || (ALIGNMENT != CPP_WORDSZ/8) || !defined(UNIX_LIKE)
37 # error Configuration doesnt support MAKE_BACK_GRAPH
40 /* We store single back pointers directly in the object's oh_bg_ptr field. */
41 /* If there is more than one ptr to an object, we store q | FLAG_MANY, */
42 /* where q is a pointer to a back_edges object. */
43 /* Every once in a while we use a back_edges object even for a single */
44 /* pointer, since we need the other fields in the back_edges structure to */
45 /* be present in some fraction of the objects. Otherwise we get serious */
46 /* performance issues. */
49 typedef struct back_edges_struct {
50 word n_edges; /* Number of edges, including those in continuation */
53 # define RETAIN 1 /* Directly points to a reachable object; */
54 /* retain for next GC. */
55 unsigned short height_gc_no;
56 /* If height > 0, then the GC_gc_no value when it */
57 /* was computed. If it was computed this cycle, then */
58 /* it is current. If it was computed during the */
59 /* last cycle, then it represents the old height, */
60 /* which is only saved for live objects referenced by */
61 /* dead ones. This may grow due to refs from newly */
64 /* Longest path through unreachable nodes to this node */
65 /* that we found using depth first search. */
67 # define HEIGHT_UNKNOWN ((signed_word)(-2))
68 # define HEIGHT_IN_PROGRESS ((signed_word)(-1))
70 struct back_edges_struct *cont;
71 /* Pointer to continuation structure; we use only the */
72 /* edges field in the continuation. */
73 /* also used as free list link. */
76 /* Allocate a new back edge structure. Should be more sophisticated */
77 /* if this were production code. */
78 #define MAX_BACK_EDGE_STRUCTS 100000
79 static back_edges *back_edge_space = 0;
80 int GC_n_back_edge_structs = 0; /* Serves as pointer to never used */
81 /* back_edges space. */
82 static back_edges *avail_back_edges = 0;
83 /* Pointer to free list of deallocated */
84 /* back_edges structures. */
86 static back_edges * new_back_edges(void)
88 if (0 == back_edge_space) {
89 back_edge_space = (back_edges *)
90 GET_MEM(MAX_BACK_EDGE_STRUCTS*sizeof(back_edges));
91 GC_add_to_our_memory((ptr_t)back_edge_space,
92 MAX_BACK_EDGE_STRUCTS*sizeof(back_edges));
94 if (0 != avail_back_edges) {
95 back_edges * result = avail_back_edges;
96 avail_back_edges = result -> cont;
100 if (GC_n_back_edge_structs >= MAX_BACK_EDGE_STRUCTS - 1) {
101 ABORT("needed too much space for back edges: adjust "
102 "MAX_BACK_EDGE_STRUCTS");
104 return back_edge_space + (GC_n_back_edge_structs++);
107 /* Deallocate p and its associated continuation structures. */
108 static void deallocate_back_edges(back_edges *p)
110 back_edges *last = p;
112 while (0 != last -> cont) last = last -> cont;
113 last -> cont = avail_back_edges;
114 avail_back_edges = p;
117 /* Table of objects that are currently on the depth-first search */
118 /* stack. Only objects with in-degree one are in this table. */
119 /* Other objects are identified using HEIGHT_IN_PROGRESS. */
120 /* FIXME: This data structure NEEDS IMPROVEMENT. */
121 #define INITIAL_IN_PROGRESS 10000
122 static ptr_t * in_progress_space = 0;
123 static size_t in_progress_size = 0;
124 static size_t n_in_progress = 0;
126 static void push_in_progress(ptr_t p)
128 if (n_in_progress >= in_progress_size)
129 if (in_progress_size == 0) {
130 in_progress_size = INITIAL_IN_PROGRESS;
131 in_progress_space = (ptr_t *)GET_MEM(in_progress_size * sizeof(ptr_t));
132 GC_add_to_our_memory((ptr_t)in_progress_space,
133 in_progress_size * sizeof(ptr_t));
135 ptr_t * new_in_progress_space;
136 in_progress_size *= 2;
137 new_in_progress_space = (ptr_t *)
138 GET_MEM(in_progress_size * sizeof(ptr_t));
139 GC_add_to_our_memory((ptr_t)new_in_progress_space,
140 in_progress_size * sizeof(ptr_t));
141 BCOPY(in_progress_space, new_in_progress_space,
142 n_in_progress * sizeof(ptr_t));
143 in_progress_space = new_in_progress_space;
144 /* FIXME: This just drops the old space. */
146 if (in_progress_space == 0)
147 ABORT("MAKE_BACK_GRAPH: Out of in-progress space: "
148 "Huge linear data structure?");
149 in_progress_space[n_in_progress++] = p;
152 static GC_bool is_in_progress(ptr_t p)
155 for (i = 0; i < n_in_progress; ++i) {
156 if (in_progress_space[i] == p) return TRUE;
161 static void pop_in_progress(ptr_t p)
164 GC_ASSERT(in_progress_space[n_in_progress] == p);
167 #define GET_OH_BG_PTR(p) \
168 (ptr_t)REVEAL_POINTER(((oh *)(p)) -> oh_bg_ptr)
169 #define SET_OH_BG_PTR(p,q) (((oh *)(p)) -> oh_bg_ptr) = HIDE_POINTER(q)
171 /* Execute s once for each predecessor q of p in the points-to graph. */
172 /* s should be a bracketed statement. We declare q. */
173 #define FOR_EACH_PRED(q, p, s) \
175 ptr_t q = GET_OH_BG_PTR(p); \
176 if (!((word)q & FLAG_MANY)) { \
177 if (q && !((word)q & 1)) s \
178 /* !((word)q & 1) checks for a misnterpreted freelist link */ \
180 back_edges *orig_be_ = (back_edges *)((word)q & ~FLAG_MANY); \
181 back_edges *be_ = orig_be_; \
182 int total_, local_; \
183 int n_edges_ = be_ -> n_edges; \
184 for (total_ = 0, local_ = 0; total_ < n_edges_; ++local_, ++total_) { \
185 if (local_ == MAX_IN) { \
189 q = be_ -> edges[local_]; s \
194 /* Ensure that p has a back_edges structure associated with it. */
195 static void ensure_struct(ptr_t p)
197 ptr_t old_back_ptr = GET_OH_BG_PTR(p);
199 if (!((word)old_back_ptr & FLAG_MANY)) {
200 back_edges *be = new_back_edges();
202 if (0 == old_back_ptr) {
206 be -> edges[0] = old_back_ptr;
208 be -> height = HEIGHT_UNKNOWN;
209 be -> height_gc_no = GC_gc_no - 1;
210 GC_ASSERT(be >= back_edge_space);
211 SET_OH_BG_PTR(p, (word)be | FLAG_MANY);
215 /* Add the (forward) edge from p to q to the backward graph. Both p */
216 /* q are pointers to the object base, i.e. pointers to an oh. */
217 static void add_edge(ptr_t p, ptr_t q)
219 ptr_t old_back_ptr = GET_OH_BG_PTR(q);
220 back_edges * be, *be_cont;
222 static unsigned random_number = 13;
223 # define GOT_LUCKY_NUMBER (((++random_number) & 0x7f) == 0)
224 /* A not very random number we use to occasionally allocate a */
225 /* back_edges structure even for a single backward edge. This */
226 /* prevents us from repeatedly tracing back through very long */
227 /* chains, since we will have some place to store height and */
228 /* in_progress flags along the way. */
230 GC_ASSERT(p == GC_base(p) && q == GC_base(q));
231 if (!GC_HAS_DEBUG_INFO(q) || !GC_HAS_DEBUG_INFO(p)) {
232 /* This is really a misinterpreted free list link, since we saw */
233 /* a pointer to a free list. Dont overwrite it! */
236 if (0 == old_back_ptr) {
238 if (GOT_LUCKY_NUMBER) ensure_struct(q);
241 /* Check whether it was already in the list of predecessors. */
242 FOR_EACH_PRED(pred, q, { if (p == pred) return; });
244 old_back_ptr = GET_OH_BG_PTR(q);
245 be = (back_edges *)((word)old_back_ptr & ~FLAG_MANY);
246 for (i = be -> n_edges, be_cont = be; i > MAX_IN;
247 be_cont = be_cont -> cont, i -= MAX_IN) {}
249 be_cont -> cont = new_back_edges();
250 be_cont = be_cont -> cont;
253 be_cont -> edges[i] = p;
255 if (be -> n_edges == 100) {
257 if (GC_print_stats) {
258 GC_err_printf("The following object has in-degree >= 100:\n");
259 GC_print_heap_obj(q);
265 typedef void (*per_object_func)(ptr_t p, size_t n_bytes, word gc_descr);
267 static void per_object_helper(struct hblk *h, word fn)
270 size_t sz = hhdr -> hb_sz;
271 word descr = hhdr -> hb_descr;
272 per_object_func f = (per_object_func)fn;
276 f((ptr_t)(h -> hb_body + i), sz, descr);
278 } while (i + sz <= BYTES_TO_WORDS(HBLKSIZE));
281 void GC_apply_to_each_object(per_object_func f)
283 GC_apply_to_all_blocks(per_object_helper, (word)f);
286 static void reset_back_edge(ptr_t p, size_t n_bytes, word gc_descr)
288 /* Skip any free list links, or dropped blocks */
289 if (GC_HAS_DEBUG_INFO(p)) {
290 ptr_t old_back_ptr = GET_OH_BG_PTR(p);
291 if ((word)old_back_ptr & FLAG_MANY) {
292 back_edges *be = (back_edges *)((word)old_back_ptr & ~FLAG_MANY);
293 if (!(be -> flags & RETAIN)) {
294 deallocate_back_edges(be);
299 GC_ASSERT(GC_is_marked(p));
301 /* Back edges may point to objects that will not be retained. */
302 /* Delete them for now, but remember the height. */
303 /* Some will be added back at next GC. */
305 if (0 != be -> cont) {
306 deallocate_back_edges(be -> cont);
310 GC_ASSERT(GC_is_marked(p));
312 /* We only retain things for one GC cycle at a time. */
313 be -> flags &= ~RETAIN;
315 } else /* Simple back pointer */ {
316 /* Clear to avoid dangling pointer. */
322 static void add_back_edges(ptr_t p, size_t n_bytes, word gc_descr)
324 word *currentp = (word *)(p + sizeof(oh));
326 /* For now, fix up non-length descriptors conservatively. */
327 if((gc_descr & GC_DS_TAGS) != GC_DS_LENGTH) {
330 while (currentp < (word *)(p + gc_descr)) {
331 word current = *currentp++;
332 FIXUP_POINTER(current);
333 if (current >= (word)GC_least_plausible_heap_addr &&
334 current <= (word)GC_greatest_plausible_heap_addr) {
335 ptr_t target = GC_base((void *)current);
343 /* Rebuild the representation of the backward reachability graph. */
344 /* Does not examine mark bits. Can be called before GC. */
345 void GC_build_back_graph(void)
347 GC_apply_to_each_object(add_back_edges);
350 /* Return an approximation to the length of the longest simple path */
351 /* through unreachable objects to p. We refer to this as the height */
353 static word backwards_height(ptr_t p)
356 ptr_t back_ptr = GET_OH_BG_PTR(p);
359 if (0 == back_ptr) return 1;
360 if (!((word)back_ptr & FLAG_MANY)) {
361 if (is_in_progress(p)) return 0; /* DFS back edge, i.e. we followed */
362 /* an edge to an object already */
363 /* on our stack: ignore */
365 result = backwards_height(back_ptr)+1;
369 be = (back_edges *)((word)back_ptr & ~FLAG_MANY);
370 if (be -> height >= 0 && be -> height_gc_no == GC_gc_no)
372 /* Ignore back edges in DFS */
373 if (be -> height == HEIGHT_IN_PROGRESS) return 0;
374 result = (be -> height > 0? be -> height : 1);
375 be -> height = HEIGHT_IN_PROGRESS;
376 FOR_EACH_PRED(q, p, {
378 if (GC_is_marked(q) && !(FLAG_MANY & (word)GET_OH_BG_PTR(p))) {
380 GC_log_printf("Found bogus pointer from 0x%lx to 0x%lx\n", q, p);
381 /* Reachable object "points to" unreachable one. */
382 /* Could be caused by our lax treatment of GC descriptors. */
385 this_height = backwards_height(q);
387 if (this_height >= result) result = this_height + 1;
389 be -> height = result;
390 be -> height_gc_no = GC_gc_no;
395 ptr_t GC_deepest_obj;
397 /* Compute the maximum height of every unreachable predecessor p of a */
398 /* reachable object. Arrange to save the heights of all such objects p */
399 /* so that they can be used in calculating the height of objects in the */
401 /* Set GC_max_height to be the maximum height we encounter, and */
402 /* GC_deepest_obj to be the corresponding object. */
403 static void update_max_height(ptr_t p, size_t n_bytes, word gc_descr)
405 if (GC_is_marked(p) && GC_HAS_DEBUG_INFO(p)) {
408 ptr_t p_deepest_obj = 0;
412 /* If we remembered a height last time, use it as a minimum. */
413 /* It may have increased due to newly unreachable chains pointing */
414 /* to p, but it can't have decreased. */
415 back_ptr = GET_OH_BG_PTR(p);
416 if (0 != back_ptr && ((word)back_ptr & FLAG_MANY)) {
417 be = (back_edges *)((word)back_ptr & ~FLAG_MANY);
418 if (be -> height != HEIGHT_UNKNOWN) p_height = be -> height;
420 FOR_EACH_PRED(q, p, {
421 if (!GC_is_marked(q) && GC_HAS_DEBUG_INFO(q)) {
424 q_height = backwards_height(q);
425 if (q_height > p_height) {
432 /* Remember the height for next time. */
435 back_ptr = GET_OH_BG_PTR(p);
436 be = (back_edges *)((word)back_ptr & ~FLAG_MANY);
438 be -> flags |= RETAIN;
439 be -> height = p_height;
440 be -> height_gc_no = GC_gc_no;
442 if (p_height > GC_max_height) {
443 GC_max_height = p_height;
444 GC_deepest_obj = p_deepest_obj;
449 word GC_max_max_height = 0;
451 void GC_traverse_back_graph(void)
454 GC_apply_to_each_object(update_max_height);
455 if (0 != GC_deepest_obj)
456 GC_set_mark_bit(GC_deepest_obj); /* Keep it until we can print it. */
459 void GC_print_back_graph_stats(void)
461 GC_printf("Maximum backwards height of reachable objects at GC %lu is %ld\n",
462 (unsigned long) GC_gc_no, (unsigned long)GC_max_height);
463 if (GC_max_height > GC_max_max_height) {
464 GC_max_max_height = GC_max_height;
465 GC_printf("The following unreachable object is last in a longest chain "
466 "of unreachable objects:\n");
467 GC_print_heap_obj(GC_deepest_obj);
469 if (GC_print_stats) {
470 GC_log_printf("Needed max total of %ld back-edge structs\n",
471 GC_n_back_edge_structs);
473 GC_apply_to_each_object(reset_back_edge);
477 #endif /* MAKE_BACK_GRAPH */