static remset_t *
create_labelled_remset_with_owner_attrib
( int tbl_entries, /* size of hash table, 0=default */
int pool_entries, /* size of remset, 0 = default */
int major_id, /* for stats */
int minor_id, /* for stats */
unsigned owner_attrib
)
{
word *heapptr;
remset_t *rs;
remset_data_t *data;
pool_t *p;
assert( tbl_entries >= 0 && (tbl_entries == 0 || ilog2( tbl_entries ) != -1));
assert( pool_entries >= 0 );
if (pool_entries == 0) pool_entries = DEFAULT_REMSET_POOLSIZE;
if (tbl_entries == 0) tbl_entries = DEFAULT_REMSET_TBLSIZE;
annoyingmsg( "Allocated remembered set\n hash=%d pool=%d",
tbl_entries, pool_entries );
rs = (remset_t*)must_malloc( sizeof( remset_t ) );
data = (remset_data_t*)must_malloc( sizeof( remset_data_t ) );
while(1) {
heapptr = gclib_alloc_rts( tbl_entries*sizeof(word),
owner_attrib );
if (heapptr != 0) break;
memfail( MF_RTS, "Can't allocate table and SSB for remembered set." );
}
/* Hash table */
data->tbl_bot = heapptr;
heapptr += tbl_entries;
data->tbl_lim = heapptr;
/* Node pool */
p = allocate_pool_segment( pool_entries, data->mem_attribute ); /* XXX */
data->first_pool = data->curr_pool = p;
assert( data->curr_pool != 0 );
data->numpools = 1;
/* Misc */
memset( &data->stats, 0, sizeof( data->stats ));
data->pool_entries = pool_entries;
data->self = stats_new_remembered_set( major_id, minor_id );
data->mem_attribute = owner_attrib;
rs->live = 0;
rs->has_overflowed = FALSE;
rs->data = data;
rs_clear( rs );
return rs;
}
extbmp_t *create_extensible_bitmap_params( gc_t *gc, gc_param_t *info,
int leaf_bytes,
int entries_per_node )
{
/* Creates bitmap representing empty set of addresses */
extbmp_t *ebmp;
int depth;
int max_leaves;
int leaf_words = CEILDIV(leaf_bytes, sizeof(word));
long long address_range_in_words;
assert( (leaf_bytes % MIN_BYTES_PER_OBJECT) == 0 );
max_leaves = SHIFTED_ADDRESS_SPACE / (BITS_PER_WORD * leaf_words);
assert( max_leaves > 0 );
{ /* calculate max depth of tree */
int i = 0;
long long tot = 1;
long long addr_range = ADDRS_PER_WORD * leaf_words;
while (tot < max_leaves) {
i += 1;
tot *= entries_per_node;
addr_range *= entries_per_node;
}
depth = i;
address_range_in_words = addr_range;
}
ebmp = (extbmp_t*)must_malloc( sizeof( extbmp_t ));
ebmp->gc = gc;
ebmp->leaf_words = CEILDIV(leaf_bytes,sizeof(word));
ebmp->entries_per_inode = entries_per_node;
ebmp->depth = depth;
ebmp->tree
= alloc_inode( ebmp,
address_range_in_words,
0,
(((long long)SHIFTED_ADDRESS_SPACE) << BIT_IDX_SHIFT));
ebmp->mru_cache.leaf = NULL;
ebmp->mru_cache.first_addr_for_leaf = 0;
ebmp->gno_count = gc->gno_count;
ebmp->gno_to_leaf = (leaf_t**)must_malloc( sizeof(leaf_t*) * ebmp->gno_count );
{
int i;
for (i = 0; i < ebmp->gno_count; i++) {
ebmp->gno_to_leaf[i] = NULL;
}
}
ebmp->leaf_count = 0;
annoyingmsg( "ebmp{gc,leaf_words=%d,entries_per_inode=%d,depth=%d,tree} max_leaves:%d",
ebmp->leaf_words, ebmp->entries_per_inode, ebmp->depth, max_leaves );
return ebmp;
}
static los_list_t *make_los_list( void )
{
los_list_t *list;
list = (los_list_t*)must_malloc( sizeof( los_list_t ) );
list->header = (word*)must_malloc( HEADER_WORDS*sizeof(word) )+HEADER_WORDS;
set_size( list->header, 0 );
clear_list( list );
return list;
}
static BUFFER bufnew(size_t hint) {
BUFFER buf = NULL;
if (hint < 1024) {
hint = 1024;
}
buf = must_malloc(sizeof(*buf));
buf->capacity = hint;
buf->data = must_malloc(hint);
buf->gapstart = 1;
buf->gapend = hint - 1;
return buf;
}
msgc_context_t *msgc_begin( gc_t *gc )
{
caddr_t lowest, highest;
int doublewords;
msgc_context_t *context;
context = must_malloc( sizeof( msgc_context_t ) );
context->gc = gc;
gclib_memory_range( &lowest, &highest );
context->lowest_heap_address = (word*)lowest;
context->highest_heap_address = (word*)highest;
doublewords = roundup(highest-lowest,(2*sizeof(word)))/(2*sizeof(word));
context->words_in_bitmap =
roundup(doublewords,(8*sizeof(word)))/(8*sizeof(word));
context->bitmap =
gclib_alloc_rts( context->words_in_bitmap * sizeof(word), 0 );
memset( context->bitmap, 0, context->words_in_bitmap*sizeof(word) );
context->stack.seg = 0;
context->stack.stkp = 0;
context->stack.stkbot = 0;
context->stack.stklim = 0;
push_segment( &context->stack );
context->los_stack.seg = 0;
context->los_stack.stkp = 0;
context->los_stack.stkbot = 0;
context->los_stack.stklim = 0;
push_segment( &context->los_stack );
return context;
}
old_heap_t *create_old_heap_t(
char *id,
word code,
int (*initialize)( old_heap_t *heap ),
void (*collect)( old_heap_t *heap, gc_type_t request ),
void (*collect_into)( old_heap_t *heap, gc_type_t request, old_heap_t *to ),
void (*before_collection)( old_heap_t *heap ),
void (*after_collection)( old_heap_t *heap ),
void (*stats)( old_heap_t *heap ),
word *(*data_load_area)( old_heap_t *heap, int nbytes ),
int (*load_prepare)( old_heap_t *heap, metadata_block_t *m,
heapio_t *h, word **lo, word **hi ),
int (*load_data)( old_heap_t *heap, metadata_block_t *m, heapio_t *h ),
void (*set_policy)( old_heap_t *heap, int op, int value ),
void (*set_gen_no)( old_heap_t *heap, int gen_no ),
semispace_t *(*current_space)( old_heap_t *heap ),
void (*assimilate)( old_heap_t *heap, semispace_t *ss ),
void *(*enumerate)( old_heap_t *heap,
void *visitor( word *addr, int tag, void *accum ),
void *accum_init ),
bool (*is_address_mapped)( old_heap_t *heap, word *addr, bool noisy ),
void (*synchronize)( old_heap_t *heap ),
void *data
)
{
old_heap_t *heap;
heap = (old_heap_t*)must_malloc( sizeof( old_heap_t ) );
heap->collector = 0;
heap->id = id;
heap->code = code;
heap->maximum = 0;
heap->allocated = 0;
heap->data = data;
heap->initialize = (initialize ? initialize : default_initialize);
heap->collect = collect;
heap->collect_into = collect_into;
heap->before_collection = before_collection;
heap->after_collection = after_collection;
heap->stats = stats;
heap->data_load_area = data_load_area;
heap->load_prepare = load_prepare;
heap->load_data = load_data;
heap->set_policy = (set_policy ? set_policy : default_set_policy);
heap->set_gen_no = set_gen_no;
heap->current_space = current_space;
heap->assimilate = assimilate;
heap->enumerate = enumerate;
heap->is_address_mapped = is_address_mapped;
heap->has_popular_objects = FALSE;
heap->bytes_live_last_major_gc = 0;
heap->words_from_nursery_last_major_gc = 0;
heap->reallocate_whole_semispace = FALSE;
heap->synchronize = synchronize;
return heap;
}
los_t *create_los( int generations )
{
los_t *los;
int i;
assert( generations > 0 );
los = (los_t*)must_malloc( sizeof( los_t ) );
los->generations = generations;
los->object_lists =
(los_list_t**)must_malloc( generations*sizeof( los_list_t* ) );
for ( i=0 ; i < generations ; i++ )
los->object_lists[i] = make_los_list();
los->mark1 = make_los_list();
los->mark2 = make_los_list();
return los;
}
void osdep_openfile( word w_fn, word w_flags, word w_mode )
{
char *fn = string2asciiz( w_fn );
int i, flags = nativeint( w_flags );
char newflags[5];
char *p = newflags;
int mode = 0;
FILE *fp;
#ifdef USE_STDIO
check_standard_filedes();
#endif
/* This is a real thin pipe for the semantics ... */
if (flags & 0x01) { *p++ = 'r'; mode |= MODE_READ; }
if (flags & 0x02) { *p++ = 'w'; mode |= MODE_WRITE; }
if (flags & 0x04) *p++ = '+';
if (flags & 0x20) { *p++ = 'b'; mode |= MODE_BINARY; }
*p = '\0';
if (!(mode & MODE_BINARY))
mode |= MODE_TEXT;
if (fn == 0) {
globals[ G_RESULT ] = fixnum( -1 );
return;
}
fp = fopen( fn, newflags );
if (fp == NULL) {
globals[ G_RESULT ] = fixnum( -1 );
return;
}
/* Now register the file and return the table index. */
for ( i=0 ; i < num_fds && fdarray[i].fp != 0 ; i++ )
;
if (i == num_fds) {
int n = max(2*num_fds,5);
struct finfo *narray = (struct finfo*)must_malloc( sizeof(struct finfo)*n );
if (fdarray != 0)
memcpy( narray, fdarray, sizeof(struct finfo)*num_fds );
for ( i=num_fds ; i < n ; i++ )
{
narray[i].fp = 0;
narray[i].mode = 0;
}
i = num_fds;
num_fds = n;
if (fdarray != 0)
free( fdarray );
fdarray = narray;
}
fdarray[i].fp = fp;
fdarray[i].mode = mode;
globals[ G_RESULT ] = fixnum(i);
}
LISP lputenv(LISP lstr)
{char *orig,*cpy;
orig = get_c_string(lstr);
/* unix putenv keeps a pointer to the string we pass,
therefore we must make a fresh copy, which is memory leaky. */
cpy = (char *) must_malloc(strlen(orig)+1);
strcpy(cpy,orig);
if (putenv(cpy))
return(err("putenv",llast_c_errmsg(-1)));
else
return(NIL);}
static char* bufstring(BUFFER self, char** buf, size_t* bufsize) {
size_t new_size = self->gapstart + (self->capacity - self->gapend);
if ( (*bufsize) < new_size || (*buf) == NULL ) {
*bufsize = new_size;
free(*buf);
*buf = must_malloc(new_size);
}
strcpy( (*buf), bufbefore(self) );
strcpy( (*buf) + self->gapstart - 1 , bufafter(self) );
return *buf;
}
static void check_standard_filedes()
{
if (fdarray == 0)
{
fdarray = (struct finfo*)must_malloc( sizeof(struct finfo)*3 );
num_fds = 3;
fdarray[0].fp = stdin;
fdarray[0].mode = MODE_TEXT | MODE_READ | MODE_INTERMITTENT;
fdarray[1].fp = stdout;
fdarray[1].mode = MODE_TEXT | MODE_WRITE;
fdarray[2].fp = stderr;
fdarray[2].mode = MODE_TEXT | MODE_WRITE;
}
}
EXPORT gc_mmu_log_t *
create_gc_mmu_log( int *window_lens, int buffer_length, gc_log_phase_t init )
{
gc_mmu_log_t *log;
log = (gc_mmu_log_t*)must_malloc( sizeof( gc_mmu_log_t ));
log->buffer.entries = (struct log_entry*)
must_malloc( buffer_length*sizeof( struct log_entry ));
log->buffer.capacity = buffer_length;
log->buffer.first = 0;
log->buffer.end = 0;
log->in_progress.phase = init;
log->in_progress.start_real = osdep_realclock();
log->in_progress.start_cpu = osdep_cpuclock();
{
int i;
i = 0;
while ( window_lens[i] != -1 ) {
i++;
}
log->windows.len = i;
log->windows.array = (struct event_window*)
must_malloc( log->windows.len*sizeof( struct event_window ));
for ( i = 0; i < log->windows.len; i++ ) {
log->windows.array[i].size = window_lens[i];
clear_event_window( &log->windows.array[i] );
}
}
CHECK_REP( log );
return log;
}
LISP lgdPoint(LISP args)
{ LISP result,l;
long iflag,j,m,n = nlength(args);
gdPointPtr pt;
if ((n % 2) || (!n))
err("must be an even positive length",args);
m = n / 2;
result = cons(NIL,NIL);
result->type = tc_gdpoint;
iflag = no_interrupt(1);
pt = (gdPointPtr) must_malloc(sizeof(gdPoint) * m);
result->storage_as.string.data = (char *) pt;
result->storage_as.string.dim = m;
no_interrupt(iflag);
for(j=0,l=args; j<m; ++j,l=cddr(l))
{ pt[j].x = get_c_long(car(l));
pt[j].y = get_c_long(cadr(l));
}
return(result);
}
static void bufexpand(BUFFER self) {
char *new_data;
char *old_data = self->data;
size_t new_capacity = self->capacity + BUFFER_GROW_BY;
if (new_capacity <= self->capacity) {
fprintf(stderr, "%s: cannot expand buffer: integer overflow\n",
PROGRAM_NAME);
abort();
}
new_data = must_malloc(new_capacity);
memcpy(new_data, bufbefore(self), self->gapstart);
memcpy(new_data + (new_capacity - self->gapend),
bufafter(self),
self->capacity - self->gapend);
self->data = new_data;
self->gapend = new_capacity - self->gapend;
free(old_data);
}
msgc_context_t *msgc_begin_range( gc_t *gc, caddr_t lowest, caddr_t highest )
{
int doublewords;
msgc_context_t *context;
context = must_malloc( sizeof( msgc_context_t ) );
context->gc = gc;
context->lowest_heap_address = (word*)lowest;
context->highest_heap_address = (word*)highest;
doublewords = roundup(highest-lowest,(2*sizeof(word)))/(2*sizeof(word));
context->words_in_bitmap =
roundup(doublewords,(8*sizeof(word)))/(8*sizeof(word));
context->bitmap =
gclib_alloc_rts( context->words_in_bitmap * sizeof(word), 0 );
context->object_visitor = NULL;
context->object_visitor_data = NULL;
context->stop_when = NULL;
context->stop_when_data = NULL;
context->signal_stop = FALSE;
context->stopped_on_obj = 0x0;
context->stopped_on_src = 0x0;
memset( context->bitmap, 0, context->words_in_bitmap*sizeof(word) );
context->stack.seg = 0;
context->stack.stkp = 0;
context->stack.stkbot = 0;
context->stack.stklim = 0;
push_segment( &context->stack );
context->los_stack.seg = 0;
context->los_stack.stkp = 0;
context->los_stack.stkbot = 0;
context->los_stack.stklim = 0;
push_segment( &context->los_stack );
return context;
}
static young_heap_t *allocate_nursery( int gen_no, gc_t *gc )
{
young_data_t *data;
young_heap_t *heap;
data = (young_data_t*)must_malloc( sizeof( young_data_t ) );
heap = create_young_heap_t( "nursery",
HEAPCODE_YOUNG_1SPACE,
0, /* initialize */
create_initial_stack,
allocate,
make_room,
collect,
before_collection,
after_collection,
0, /* set_policy */
free_space,
stats,
data_load_area,
0,
0,
creg_get,
creg_set,
stack_underflow,
stack_overflow,
is_address_mapped,
data );
heap->collector = gc;
data->self = stats_new_generation( gen_no, 0 );
data->gen_no = gen_no;
data->los_live = 0;
data->stack_live = 0;
data->not_used = 0;
data->havestats = FALSE;
return heap;
}
static void register_pointer( byte *derived, byte *original )
{
int i, j;
if (reg_next == reg_size) {
/* It's full, so compact it and see what happens */
j = 0;
for ( i=0 ; i < reg_size; i++ ) {
if (registry[i].original != 0) {
registry[j] = registry[i];
j++;
}
}
if (j < reg_size) {
/* Compaction succeeded */
reg_next = j;
}
else {
/* Compaction failed: registry is full, so double its size. */
struct regentry *new_reg;
int k;
k = max( 256, reg_size * 2 );
new_reg = (struct regentry *)must_malloc( k*sizeof( struct regentry ) );
for ( i=0 ; i < reg_size ; i++ )
new_reg[i] = registry[i];
if (registry != 0) free( registry );
registry = new_reg;
reg_size = k;
}
}
registry[reg_next].original = original;
registry[reg_next].derived = derived;
reg_next++;
}
