/* we have not yet allocated. */
GC_INNER ptr_t GC_build_fl(struct hblk *h, size_t sz, GC_bool clear,
ptr_t list)
{
word *p, *prev;
word *last_object; /* points to last object in new hblk */
/* Do a few prefetches here, just because its cheap. */
/* If we were more serious about it, these should go inside */
/* the loops. But write prefetches usually don't seem to */
/* matter much. */
PREFETCH_FOR_WRITE((ptr_t)h);
PREFETCH_FOR_WRITE((ptr_t)h + 128);
PREFETCH_FOR_WRITE((ptr_t)h + 256);
PREFETCH_FOR_WRITE((ptr_t)h + 378);
/* Handle small objects sizes more efficiently. For larger objects */
/* the difference is less significant. */
# ifndef SMALL_CONFIG
switch (sz) {
case 2: if (clear) {
return GC_build_fl_clear2(h, list);
} else {
return GC_build_fl2(h, list);
}
case 4: if (clear) {
return GC_build_fl_clear4(h, list);
} else {
return GC_build_fl4(h, list);
}
default:
break;
}
# endif /* !SMALL_CONFIG */
/* Clear the page if necessary. */
if (clear) BZERO(h, HBLKSIZE);
/* Add objects to free list */
p = (word *)(h -> hb_body) + sz; /* second object in *h */
prev = (word *)(h -> hb_body); /* One object behind p */
last_object = (word *)((char *)h + HBLKSIZE);
last_object -= sz;
/* Last place for last object to start */
/* make a list of all objects in *h with head as last object */
while (p <= last_object) {
/* current object's link points to last object */
obj_link(p) = (ptr_t)prev;
prev = p;
p += sz;
}
p -= sz; /* p now points to last object */
/*
* put p (which is now head of list of objects in *h) as first
* pointer in the appropriate free list for this size.
*/
obj_link(h -> hb_body) = list;
return ((ptr_t)p);
}
/* The same for size 4 uncleared objects. */
STATIC ptr_t GC_build_fl4(struct hblk *h, ptr_t ofl)
{
word * p = (word *)(h -> hb_body);
word * lim = (word *)(h + 1);
p[0] = (word)ofl;
p[4] = (word)p;
p += 8;
for (; (word)p < (word)lim; p += 8) {
PREFETCH_FOR_WRITE((ptr_t)(p+64));
p[0] = (word)(p-4);
p[4] = (word)p;
};
return((ptr_t)(p-4));
}
GC_PTR GC_local_malloc(size_t bytes)
{
if (EXPECT(!SMALL_ENOUGH(bytes),0)) {
return(GC_malloc(bytes));
} else {
int index = INDEX_FROM_BYTES(bytes);
ptr_t * my_fl;
ptr_t my_entry;
# if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC)
GC_key_t k = GC_thread_key;
# endif
void * tsd;
# if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC)
if (EXPECT(0 == k, 0)) {
/* This can happen if we get called when the world is */
/* being initialized. Whether we can actually complete */
/* the initialization then is unclear. */
GC_init_parallel();
k = GC_thread_key;
}
# endif
tsd = GC_getspecific(GC_thread_key);
# ifdef GC_ASSERTIONS
LOCK();
GC_ASSERT(tsd == (void *)GC_lookup_thread(pthread_self()));
UNLOCK();
# endif
my_fl = ((GC_thread)tsd) -> normal_freelists + index;
my_entry = *my_fl;
if (EXPECT((word)my_entry >= HBLKSIZE, 1)) {
ptr_t next = obj_link(my_entry);
GC_PTR result = (GC_PTR)my_entry;
*my_fl = next;
obj_link(my_entry) = 0;
PREFETCH_FOR_WRITE(next);
return result;
} else if ((word)my_entry - 1 < DIRECT_GRANULES) {
*my_fl = my_entry + index + 1;
return GC_malloc(bytes);
} else {
GC_generic_malloc_many(BYTES_FROM_INDEX(index), NORMAL, my_fl);
if (*my_fl == 0) return GC_oom_fn(bytes);
return GC_local_malloc(bytes);
}
}
}
/* The same for size 4 cleared objects. */
STATIC ptr_t GC_build_fl_clear4(struct hblk *h, ptr_t ofl)
{
word * p = (word *)(h -> hb_body);
word * lim = (word *)(h + 1);
p[0] = (word)ofl;
p[1] = 0;
p[2] = 0;
p[3] = 0;
p += 4;
for (; (word)p < (word)lim; p += 4) {
PREFETCH_FOR_WRITE((ptr_t)(p+64));
p[0] = (word)(p-4);
p[1] = 0;
CLEAR_DOUBLE(p+2);
};
return((ptr_t)(p-4));
}
GC_API void * GC_CALL GC_finalized_malloc(size_t client_lb,
const struct GC_finalizer_closure *fclos)
{
size_t lb = client_lb + sizeof(void *);
size_t lg = ROUNDED_UP_GRANULES(lb);
GC_tlfs tsd;
void *result;
void **tiny_fl, **my_fl, *my_entry;
void *next;
if (EXPECT(lg >= GC_TINY_FREELISTS, FALSE))
return GC_core_finalized_malloc(client_lb, fclos);
tsd = GC_getspecific(GC_thread_key);
tiny_fl = tsd->finalized_freelists;
my_fl = tiny_fl + lg;
my_entry = *my_fl;
while (EXPECT((word)my_entry
<= DIRECT_GRANULES + GC_TINY_FREELISTS + 1, FALSE)) {
if ((word)my_entry - 1 < DIRECT_GRANULES) {
*my_fl = (ptr_t)my_entry + lg + 1;
return GC_core_finalized_malloc(client_lb, fclos);
} else {
GC_generic_malloc_many(GC_RAW_BYTES_FROM_INDEX(lg),
GC_finalized_kind, my_fl);
my_entry = *my_fl;
if (my_entry == 0) {
return (*GC_get_oom_fn())(lb);
}
}
}
next = obj_link(my_entry);
result = (void *)my_entry;
*my_fl = next;
obj_link(result) = 0;
((const void **)result)[GRANULES_TO_WORDS(lg) - 1] = fclos;
PREFETCH_FOR_WRITE(next);
return result;
}
