/* A size of 0 granules is used for large objects. */
GC_INNER GC_bool GC_add_map_entry(size_t granules)
{
unsigned displ;
unsigned short * new_map;
if (granules > BYTES_TO_GRANULES(MAXOBJBYTES)) granules = 0;
if (GC_obj_map[granules] != 0) {
return(TRUE);
}
new_map = (unsigned short *)GC_scratch_alloc(MAP_LEN * sizeof(short));
if (new_map == 0) return(FALSE);
GC_COND_LOG_PRINTF(
"Adding block map for size of %u granules (%u bytes)\n",
(unsigned)granules, (unsigned)GRANULES_TO_BYTES(granules));
if (granules == 0) {
for (displ = 0; displ < BYTES_TO_GRANULES(HBLKSIZE); displ++) {
new_map[displ] = 1; /* Nonzero to get us out of marker fast path. */
}
} else {
for (displ = 0; displ < BYTES_TO_GRANULES(HBLKSIZE); displ++) {
new_map[displ] = (unsigned short)(displ % granules);
}
}
GC_obj_map[granules] = new_map;
return(TRUE);
}
STATIC void GC_check_blocks(void)
{
word bytes_in_free_blocks = GC_large_free_bytes;
GC_bytes_in_used_blocks = 0;
GC_apply_to_all_blocks(GC_add_block, (word)0);
GC_COND_LOG_PRINTF("GC_bytes_in_used_blocks = %lu,"
" bytes_in_free_blocks = %lu, heapsize = %lu\n",
(unsigned long)GC_bytes_in_used_blocks,
(unsigned long)bytes_in_free_blocks,
(unsigned long)GC_heapsize);
if (GC_bytes_in_used_blocks + bytes_in_free_blocks != GC_heapsize) {
GC_err_printf("LOST SOME BLOCKS!!\n");
}
}
/* Should be called immediately after GC_read_dirty and GC_read_changed. */
void GC_check_dirty(void)
{
int index;
unsigned i;
struct hblk *h;
ptr_t start;
GC_check_blocks();
GC_n_dirty_errors = 0;
GC_n_faulted_dirty_errors = 0;
GC_n_changed_errors = 0;
GC_n_clean = 0;
GC_n_dirty = 0;
index = 0;
for (i = 0; i < GC_n_heap_sects; i++) {
start = GC_heap_sects[i].hs_start;
for (h = (struct hblk *)start;
(word)h < (word)(start + GC_heap_sects[i].hs_bytes); h++) {
GC_update_check_page(h, index);
index++;
if (index >= NSUMS) goto out;
}
}
out:
GC_COND_LOG_PRINTF("Checked %lu clean and %lu dirty pages\n",
(unsigned long)GC_n_clean, (unsigned long)GC_n_dirty);
if (GC_n_dirty_errors > 0) {
GC_err_printf("Found %d dirty bit errors (%d were faulted)\n",
GC_n_dirty_errors, GC_n_faulted_dirty_errors);
}
if (GC_n_changed_errors > 0) {
GC_err_printf("Found %lu changed bit errors\n",
(unsigned long)GC_n_changed_errors);
GC_err_printf(
"These may be benign (provoked by nonpointer changes)\n");
# ifdef THREADS
GC_err_printf(
"Also expect 1 per thread currently allocating a stubborn obj\n");
# endif
}
for (i = 0; i < GC_n_faulted; ++i) {
GC_faulted[i] = 0; /* Don't expose block pointers to GC */
}
GC_n_faulted = 0;
}
STATIC int GC_CALLBACK GC_timeout_stop_func (void)
{
CLOCK_TYPE current_time;
static unsigned count = 0;
unsigned long time_diff;
if ((*GC_default_stop_func)())
return(1);
if ((count++ & 3) != 0) return(0);
GET_TIME(current_time);
time_diff = MS_TIME_DIFF(current_time,GC_start_time);
if (time_diff >= GC_time_limit) {
GC_COND_LOG_PRINTF(
"Abandoning stopped marking after %lu msecs (attempt %d)\n",
time_diff, GC_n_attempts);
return(1);
}
return(0);
}
void GC_print_back_graph_stats(void)
{
GC_ASSERT(I_HOLD_LOCK());
GC_printf("Maximum backwards height of reachable objects at GC %lu is %lu\n",
(unsigned long) GC_gc_no, (unsigned long)GC_max_height);
if (GC_max_height > GC_max_max_height) {
ptr_t obj = GC_deepest_obj;
GC_max_max_height = GC_max_height;
UNLOCK();
GC_err_printf(
"The following unreachable object is last in a longest chain "
"of unreachable objects:\n");
GC_print_heap_obj(obj);
LOCK();
}
GC_COND_LOG_PRINTF("Needed max total of %d back-edge structs\n",
GC_n_back_edge_structs);
GC_apply_to_each_object(reset_back_edge);
GC_deepest_obj = 0;
}
/* finalized when this finalizer is invoked. */
STATIC void GC_register_finalizer_inner(void * obj,
GC_finalization_proc fn, void *cd,
GC_finalization_proc *ofn, void **ocd,
finalization_mark_proc mp)
{
ptr_t base;
struct finalizable_object * curr_fo, * prev_fo;
size_t index;
struct finalizable_object *new_fo = 0;
hdr *hhdr = NULL; /* initialized to prevent warning. */
GC_oom_func oom_fn;
DCL_LOCK_STATE;
LOCK();
if (log_fo_table_size == -1
|| GC_fo_entries > ((word)1 << log_fo_table_size)) {
GC_grow_table((struct hash_chain_entry ***)&GC_fnlz_roots.fo_head,
&log_fo_table_size);
GC_COND_LOG_PRINTF("Grew fo table to %u entries\n",
1 << (unsigned)log_fo_table_size);
}
/* in the THREADS case we hold allocation lock. */
base = (ptr_t)obj;
for (;;) {
index = HASH2(base, log_fo_table_size);
prev_fo = 0;
curr_fo = GC_fnlz_roots.fo_head[index];
while (curr_fo != 0) {
GC_ASSERT(GC_size(curr_fo) >= sizeof(struct finalizable_object));
if (curr_fo -> fo_hidden_base == GC_HIDE_POINTER(base)) {
/* Interruption by a signal in the middle of this */
/* should be safe. The client may see only *ocd */
/* updated, but we'll declare that to be his problem. */
if (ocd) *ocd = (void *) (curr_fo -> fo_client_data);
if (ofn) *ofn = curr_fo -> fo_fn;
/* Delete the structure for base. */
if (prev_fo == 0) {
GC_fnlz_roots.fo_head[index] = fo_next(curr_fo);
} else {
fo_set_next(prev_fo, fo_next(curr_fo));
}
if (fn == 0) {
GC_fo_entries--;
/* May not happen if we get a signal. But a high */
/* estimate will only make the table larger than */
/* necessary. */
# if !defined(THREADS) && !defined(DBG_HDRS_ALL)
GC_free((void *)curr_fo);
# endif
} else {
curr_fo -> fo_fn = fn;
curr_fo -> fo_client_data = (ptr_t)cd;
curr_fo -> fo_mark_proc = mp;
/* Reinsert it. We deleted it first to maintain */
/* consistency in the event of a signal. */
if (prev_fo == 0) {
GC_fnlz_roots.fo_head[index] = curr_fo;
} else {
fo_set_next(prev_fo, curr_fo);
}
}
UNLOCK();
# ifndef DBG_HDRS_ALL
if (EXPECT(new_fo != 0, FALSE)) {
/* Free unused new_fo returned by GC_oom_fn() */
GC_free((void *)new_fo);
}
# endif
return;
}
prev_fo = curr_fo;
curr_fo = fo_next(curr_fo);
}
if (EXPECT(new_fo != 0, FALSE)) {
/* new_fo is returned by GC_oom_fn(), so fn != 0 and hhdr != 0. */
break;
}
if (fn == 0) {
if (ocd) *ocd = 0;
if (ofn) *ofn = 0;
UNLOCK();
return;
}
GET_HDR(base, hhdr);
if (EXPECT(0 == hhdr, FALSE)) {
/* We won't collect it, hence finalizer wouldn't be run. */
if (ocd) *ocd = 0;
if (ofn) *ofn = 0;
UNLOCK();
return;
}
new_fo = (struct finalizable_object *)
GC_INTERNAL_MALLOC(sizeof(struct finalizable_object),NORMAL);
if (EXPECT(new_fo != 0, TRUE))
break;
oom_fn = GC_oom_fn;
UNLOCK();
new_fo = (struct finalizable_object *)
(*oom_fn)(sizeof(struct finalizable_object));
if (0 == new_fo) {
/* No enough memory. *ocd and *ofn remains unchanged. */
return;
}
/* It's not likely we'll make it here, but ... */
LOCK();
/* Recalculate index since the table may grow and */
/* check again that our finalizer is not in the table. */
}
GC_ASSERT(GC_size(new_fo) >= sizeof(struct finalizable_object));
if (ocd) *ocd = 0;
if (ofn) *ofn = 0;
new_fo -> fo_hidden_base = GC_HIDE_POINTER(base);
new_fo -> fo_fn = fn;
new_fo -> fo_client_data = (ptr_t)cd;
new_fo -> fo_object_size = hhdr -> hb_sz;
new_fo -> fo_mark_proc = mp;
fo_set_next(new_fo, GC_fnlz_roots.fo_head[index]);
GC_fo_entries++;
GC_fnlz_roots.fo_head[index] = new_fo;
UNLOCK();
}
STATIC int GC_register_disappearing_link_inner(
struct dl_hashtbl_s *dl_hashtbl, void **link,
const void *obj, const char *tbl_log_name)
{
struct disappearing_link *curr_dl;
size_t index;
struct disappearing_link * new_dl;
DCL_LOCK_STATE;
LOCK();
GC_ASSERT(obj != NULL && GC_base_C(obj) == obj);
if (dl_hashtbl -> log_size == -1
|| dl_hashtbl -> entries > ((word)1 << dl_hashtbl -> log_size)) {
GC_grow_table((struct hash_chain_entry ***)&dl_hashtbl -> head,
&dl_hashtbl -> log_size);
GC_COND_LOG_PRINTF("Grew %s table to %u entries\n", tbl_log_name,
1 << (unsigned)dl_hashtbl -> log_size);
}
index = HASH2(link, dl_hashtbl -> log_size);
for (curr_dl = dl_hashtbl -> head[index]; curr_dl != 0;
curr_dl = dl_next(curr_dl)) {
if (curr_dl -> dl_hidden_link == GC_HIDE_POINTER(link)) {
curr_dl -> dl_hidden_obj = GC_HIDE_POINTER(obj);
UNLOCK();
return GC_DUPLICATE;
}
}
new_dl = (struct disappearing_link *)
GC_INTERNAL_MALLOC(sizeof(struct disappearing_link),NORMAL);
if (0 == new_dl) {
GC_oom_func oom_fn = GC_oom_fn;
UNLOCK();
new_dl = (struct disappearing_link *)
(*oom_fn)(sizeof(struct disappearing_link));
if (0 == new_dl) {
return GC_NO_MEMORY;
}
/* It's not likely we'll make it here, but ... */
LOCK();
/* Recalculate index since the table may grow. */
index = HASH2(link, dl_hashtbl -> log_size);
/* Check again that our disappearing link not in the table. */
for (curr_dl = dl_hashtbl -> head[index]; curr_dl != 0;
curr_dl = dl_next(curr_dl)) {
if (curr_dl -> dl_hidden_link == GC_HIDE_POINTER(link)) {
curr_dl -> dl_hidden_obj = GC_HIDE_POINTER(obj);
UNLOCK();
# ifndef DBG_HDRS_ALL
/* Free unused new_dl returned by GC_oom_fn() */
GC_free((void *)new_dl);
# endif
return GC_DUPLICATE;
}
}
}
new_dl -> dl_hidden_obj = GC_HIDE_POINTER(obj);
new_dl -> dl_hidden_link = GC_HIDE_POINTER(link);
dl_set_next(new_dl, dl_hashtbl -> head[index]);
dl_hashtbl -> head[index] = new_dl;
dl_hashtbl -> entries++;
UNLOCK();
return GC_SUCCESS;
}
/* of p. */
static word backwards_height(ptr_t p)
{
word result;
ptr_t pred = GET_OH_BG_PTR(p);
back_edges *be;
if (NULL == pred)
return 1;
if (((word)pred & FLAG_MANY) == 0) {
if (is_in_progress(p)) return 0; /* DFS back edge, i.e. we followed */
/* an edge to an object already */
/* on our stack: ignore */
push_in_progress(p);
result = backwards_height(pred) + 1;
pop_in_progress(p);
return result;
}
be = (back_edges *)((word)pred & ~FLAG_MANY);
if (be -> height >= 0 && be -> height_gc_no == (unsigned short)GC_gc_no)
return be -> height;
/* Ignore back edges in DFS */
if (be -> height == HEIGHT_IN_PROGRESS) return 0;
result = (be -> height > 0? be -> height : 1);
be -> height = HEIGHT_IN_PROGRESS;
{
back_edges *e = be;
word n_edges;
word total;
int local = 0;
if (((word)pred & FLAG_MANY) != 0) {
n_edges = e -> n_edges;
} else if (pred != NULL && ((word)pred & 1) == 0) {
/* A misinterpreted freelist link. */
n_edges = 1;
local = -1;
} else {
n_edges = 0;
}
for (total = 0; total < n_edges; ++total) {
word this_height;
if (local == MAX_IN) {
e = e -> cont;
local = 0;
}
if (local >= 0)
pred = e -> edges[local++];
/* Execute the following once for each predecessor pred of p */
/* in the points-to graph. */
if (GC_is_marked(pred) && ((word)GET_OH_BG_PTR(p) & FLAG_MANY) == 0) {
GC_COND_LOG_PRINTF("Found bogus pointer from %p to %p\n",
(void *)pred, (void *)p);
/* Reachable object "points to" unreachable one. */
/* Could be caused by our lax treatment of GC descriptors. */
this_height = 1;
} else {
this_height = backwards_height(pred);
}
if (this_height >= result)
result = this_height + 1;
}
}
be -> height = result;
be -> height_gc_no = (unsigned short)GC_gc_no;
return result;
}
