gcc/boehm-gc/nursery.c

/* 
 * Copyright (c) 1999 by Silicon Graphics.  All rights reserved.
 *
 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
 * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
 *
 * Permission is hereby granted to use or copy this program
 * for any purpose,  provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is granted,
 * provided the above notices are retained, and a notice that the code was
 * modified is included with the above copyright notice.
 */

#ifdef NURSERY
??? This implementation is incomplete.  If you are trying to
??? compile this you are doing something wrong.

#include "nursery.h"

#define SCAN_STATICS_FOR_NURSERY
	/* If this is not defined, the collector will not see 	*/
	/* references from static data areas to the nursery.	*/

struct copy_obj {
    ptr_t forward;	/* Forwarding link for copied objects.	*/
    GC_copy_descriptor descr; /* Object descriptor	*/
    word data[1];
}

ptr_t GC_nursery_start;	/* Start of nursery area.	*/
			/* Must be NURSERY_BLOCK_SIZE	*/
			/* aligned.			*/
ptr_t GC_nursery_end;	/* End of nursery area.		*/
unsigned char * GC_nursery_map;
			/* GC_nursery_map[i] != 0 if an object	*/
			/* starts on the ith 64-bit "word" of 	*/
			/* nursery.  This simple structure has	*/
			/* the advantage that 			*/
			/* allocation is cheap.  Lookup is 	*/
			/* cheap for pointers to the head of	*/
			/* an object, which should be the	*/
			/* usual case.				*/
#   define NURSERY_MAP_NOT_START	0  /* Not start of object. */
#   define NURSERY_MAP_START		1  /* Start of object.	   */
#   define NURSERY_MAP_PINNED		2  /* Start of pinned obj. */

# ifdef ALIGN_DOUBLE
#   define NURSERY_WORD_SIZE (2 * sizeof(word))
# else
#   define NURSERY_WORD_SIZE sizeof(word)
# endif

# define NURSERY_BLOCK_SIZE (HBLKSIZE/2)	
	/* HBLKSIZE must be a multiple of NURSERY_BLOCK_SIZE */
# define NURSERY_SIZE (1024 * NURSERY_BLOCK_SIZE)

size_t GC_nursery_size = NURSERY_SIZE;
			/* Must be multiple of NURSERY_BLOCK_SIZE	*/

size_t GC_nursery_blocks; /* Number of blocks in the nursery.	*/

unsigned GC_next_nursery_block; /* index of next block we will attempt 	*/
				/* allocate from during this cycle.	*/
				/* If it is pinned, we won't actually	*/
				/* use it.				*/

unsigned short *GC_pinned;	/* Number of pinned objects in ith	*/
				/* nursery block.			*/
				/* GC_pinned[i] != 0 if the ith nursery */
				/* block is pinned, and thus not used	*/
				/* for allocation.			*/

GC_copy_alloc_state global_alloc_state = (ptr_t)(-1);	/* will overflow. */

/* Array of known rescuing pointers from the heap to the nursery.	*/
  ptr_t ** nursery_rescuers;
  /* Pointer to one past the last slot in rescuer table	*/
  ptr_t ** nursery_rescuers_end;
  /* Maximum number of known rescuing pointers.			*/
# define MAX_NURSERY_RESCUERS 32*1024
  /* Add a rescuer to the list	*/
# define ADD_NURSERY_RESCUER(p) \
    if (nursery_rescuers_end >= nursery_rescuers + MAX_NURSERY_RESCUERS) { \
      ABORT("Nursery recuers overflow"); /* Fix later !!! */ \
    } else { \
      *nursery_rescuers_end++ = p; \
    }
  /* Remove rescuer at the given position in the table	*/
# define REMOVE_RESCUER(p) \
    *p = *--nursery_rescuers_end

/* Should be called with allocator lock held.	*/
GC_nursery_init() {
    GC_nursery_start = GET_MEM(GC_nursery_size);
    GC_nursery_end = GC_nursery_start + GC_nursery_size;
    GC_next_nursery_block = 0;
    if (GC_nursery_start < GC_least_plausible_heap_addr) { 
        GC_least_plausible_heap_addr = GC_nursery_start;   
    }
    if (GC_nursery_end > GC_greatest_plausible_heap_addr) {
        GC_greatest_plausible_heap_addr = GC_nursery_end;  
    }
    if (GC_nursery_start & (NURSERY_BLOCK_SIZE-1)) {
	GC_err_printf1("Nursery area is misaligned!!");
	/* This should be impossible, since GET_MEM returns HBLKSIZE */
	/* aligned chunks, and that should be a multiple of 	     */
	/* NURSERY_BLOCK_SIZE					     */
	ABORT("misaligned nursery");
    }
    GC_nursery_map = GET_MEM(GC_nursery_size/NURSERY_WORD_SIZE);
    /* Map is cleared a block at a time when we allocate from the block. */
    /* BZERO(GC_nursery_map, GC_nursery_size/NURSERY_WORD_SIZE);	 */
    GC_nursery_blocks = GC_nursery_size/NURSERY_BLOCK_SIZE;
    GC_pinned = GC_scratch_alloc(GC_nursery_blocks * sizeof(unsigned short));
    BZERO(GC_pinned, GC_nursery_blocks);
    nursery_rescuers = GET_MEM(MAX_NURSERY_RESCUERS * sizeof(ptr_t *));
    nursery_rescuers_end = nursery_rescuers;
    if (0 == GC_nursery_start || 0 == GC_nursery_map || 0 == nursery_rescuers)
	ABORT("Insufficient memory for nursery");
}

#define PIN_OBJ(p) \
    if (p >= GC_nursery_start && p < GC_nursery_end) { GC_pin_obj_checked(p); }

/* Pin the object at p, if it's in the nursery.	*/
void GC_pin_obj(ptr_t p) {
    PIN_OBJ(p);
}

void (*GC_push_proc)(ptr_t) = 0;

/* Pin the object at p, which is known to be in the nursery.	*/
void GC_pin_obj_checked(ptr_t p) {
    unsigned offset = p - GC_nursery_start;
    unsigned word_offset = BYTES_TO_WORDS(offset);
    unsigned blockno = (current - GC_nursery_start)/NURSERY_BLOCK_SIZE;
    while (GC_nursery_map[word_offset] == NURSERY_MAP_NOT_START) {
	--word_offset;    
    }
    if (GC_nursery_map[word_offset] != NURSERY_MAP_PINNED) {
        GC_nursery_map[word_offset] = NURSERY_MAP_PINNED;
        ++GC_pinned[blockno];
        ??Push object at GC_nursery_start + WORDS_TO_BYTES(word_offset)
        ??onto mark stack. 
    }
}

void GC_scan_region_for_nursery(ptr_t low, ptr_t high) {
#   if CPP_WORDSZ/8 != ALIGNMENT
      --> fix this
#   endif
    word * l = (word *)((word)low + ALIGNMENT - 1 & ~(ALIGNMENT - 1));
    word * h = (word *)((word)high & ~(ALIGNMENT - 1));
    word * p;
    for (p = l; p < h; ++p) {
	PIN_OBJ(p);
    }
}

/* Invoke GC_scan_region_for_nursery on ranges that are not excluded. */
void GC_scan_region_for_nursery_with_exclusions(ptr_t bottom, ptr_t top)
{
    struct exclusion * next;
    ptr_t excl_start;

    while (bottom < top) {
        next = GC_next_exclusion(bottom);
	if (0 == next || (excl_start = next -> e_start) >= top) {
	    GC_scan_region_for_nursery(bottom, top);
	    return;
	}
	if (excl_start > bottom)
		GC_scan_region_for_nursery(bottom, excl_start);
	bottom = next -> e_end;
    }
}


void GC_scan_stacks_for_nursery(void) {
#   ifdef THREADS
	--> fix this
#   endif
#   ifdef STACK_GROWS_DOWN
      ptr_t stack_low = GC_approx_sp();
      ptr_t stack_high = GC_stackbottom;
#   else
      ptr_t stack_low = GC_stackbottom;
      ptr_t stack_high = GC_approx_sp();
#   endif
    GC_scan_region_for_nursery(stack_low, stack_high);
#   ifdef IA64
      GC_scan_region_for_nursery(BACKING_STORE_BASE,
				 (ptr_t) GC_save_regs_ret_val);
#   endif
}

void GC_scan_roots_for_nursery(void) {
  /* Scan registers.	*/
    /* Direct GC_push_one to call GC_pin_obj instead of marking	*/
    /* and pushing objects.					*/
    /* This is a bit ugly, but we don't have to touch the	*/
    /* platform-dependent code.					*/
     
    void (*old_push_proc)(ptr_t) = GC_push_proc;
    GC_push_proc = GC_pin_obj;
    GC_push_regs();
    GC_push_proc = old_push_proc;
  GC_scan_stacks_for_nursery();
# ifdef SCAN_STATICS_FOR_NURSERY
#   if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(PCR)) \
        && !defined(SRC_M3)
      GC_remove_tmp_roots();
      GC_register_dynamic_libraries();
#   endif
    /* Mark everything in static data areas                             */
      for (i = 0; i < n_root_sets; i++) {
        GC_scan_region_for_nursery_with_exclusions (
			     GC_static_roots[i].r_start,
			     GC_static_roots[i].r_end);
     }
# endif
}

/* Array of known rescuing pointers from the heap to the nursery.	*/
ptr_t ** nursery_rescuers;

/* Caller holds allocation lock.	*/
void GC_collect_nursery(void) {
    int i;
    ptr_t scan_ptr = 0;
    STOP_WORLD;
    for (i = 0; i < GC_nursery_blocks; ++i) GC_pinned[i] = 0;
    GC_scan_roots_for_nursery();
    /* All objects referenced by roots are now pinned. 		*/
    /* Their contents are described by 			 	*/
    /* mark stack entries.					*/

    /* Pin blocks corresponding to valid allocation states.	*/
    /* that probably happens automagically if the allocation	*/
    /* states are kept where we can see them.			*/
    /* It will take work if static roots are not scanned.	*/
    /* We want to do this both for correctness and to avoid	*/
    /* promoting very young objects.				*/

    /* Somehow capture dirty bits.  Update rescuers array to	*/
    /* reflect newly valid and invalid references from dirty 	*/
    /* pages.  Other references should remain valid, since the	*/
    /* referents should have been pinned.			*/

    /* Traverse the old object heap.  Pin objects in the 	*/
    /* nursery that are ambiguously referenced, copy those	*/
    /* that are unambiguously referenced.			*/

    /* Traverse objects in mark stack.				*/
    /* If referenced object is in pinned block, add contents	*/
    /* to mark stack.  If referenced object is forwarded,	*/
    /* update pointer.  Otherwise reallocate the object	in the	*/
    /* old heap, copy its contents, and then enqueue its 	*/
    /* contents in the mark stack.				*/
    START_WORLD;
}

/* Initialize an allocation state so that it can be used for 	*/
/* allocation.  This implicitly reserves a small section of the	*/
/* nursery for use with this allocator.				*/
/* Also called to replenish an allocator that has been 		*/
/* exhausted.							*/
void GC_init_copy_alloc_state(GC_copy_alloc_state *)
    unsigned next_block;
    ptr_t block_addr;
    LOCK();
    next_block = GC_next_nursery_block;
    while(is_pinned[next_block] && next_block < GC_nursery_blocks) {
	++next_block;
    }
    if (next_block < GC_nursery_blocks) {
	block_addr = GC_nursery_start + NURSERY_BLOCK_SIZE * next_block;
   	GC_next_nursery_block = next_block + 1;
	BZERO(GC_nursery_map + next_block *
				(NURSERY_BLOCK_SIZE/NURSERY_WORD_SIZE),
	      NURSERY_BLOCK_SIZE/NURSERY_WORD_SIZE);
	*GC_copy_alloc_state = block_addr;
	UNLOCK();
    } else {
     	GC_collect_nursery();
    	GC_next_nursery_block = 0;
    	UNLOCK();
    	get_new_block(s);
    }
}

GC_PTR GC_copying_malloc2(GC_copy_descriptor *d, GC_copy_alloc_state *s) {
    size_t sz = GC_SIZE_FROM_DESCRIPTOR(d);
    ptrdiff_t offset;
    ptr_t result = *s;
    ptr_t new = result + sz;
    if (new & COPY_BLOCK_MASK <= result & COPY_BLOCK_MASK> {
	GC_init_copy_alloc_state(s);
	result = *s;
	new = result + sz;
        GC_ASSERT(new & COPY_BLOCK_MASK > result & COPY_BLOCK_MASK>
    }
    (struct copy_obj *)result -> descr = d;      
    (struct copy_obj *)result -> forward = 0;      
    offset = (result - GC_nursery_start)/NURSERY_WORD_SIZE;
    GC_nursery_map[offset] = NURSERY_MAP_NOT_START;
}

GC_PTR GC_copying_malloc(GC_copy_descriptor *d) {
}

#endif /* NURSERY */