Fcalva/cyclone
1
0
Fork 0
mirror of https://github.com/justinethier/cyclone.git synced 2025-07-16 09:17:35 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added another size heap (96 bytes)

Browse source
This commit is contained in:
Justin Ethier 2016-08-01 18:48:58 -04:00
parent ffb5b36869
commit 918e78cb21
3 changed files with 52 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
gc.c
View file

@ -59,8 +59,8 @@ static int mark_stack_i = 0;
static pthread_mutex_t heap_lock; static pthread_mutex_t heap_lock;
// Cached heap statistics // Cached heap statistics
static int cached_heap_free_sizes[4] = { 0, 0, 0, 0 }; static int cached_heap_free_sizes[7] = { 0, 0, 0, 0, 0, 0, 0 };
static int cached_heap_total_sizes[4] = { 0, 0, 0, 0 }; static int cached_heap_total_sizes[7] = { 0, 0, 0, 0, 0, 0, 0 };
// Data for each individual mutator thread // Data for each individual mutator thread
ck_array_t Cyc_mutators, old_mutators; ck_array_t Cyc_mutators, old_mutators;
@ -569,18 +569,21 @@ void *gc_alloc(gc_heap_root * hrt, size_t size, char *obj, gc_thread_data * thd,
// then try realloc. if cannot alloc now, then throw out of memory error // then try realloc. if cannot alloc now, then throw out of memory error
size = gc_heap_align(size); size = gc_heap_align(size);
if (size <= 32) { if (size <= 32) {
h = hrt->small_obj_heap;
heap_type = HEAP_SM; heap_type = HEAP_SM;
} else if (size <= 64) { } else if (size <= 64) {
h = hrt->medium_obj_heap; heap_type = HEAP_64;
heap_type = HEAP_MED; } else if (size <= 96) {
heap_type = HEAP_96;
// } else if (size <= 128) {
// heap_type = HEAP_128;
// } else if (size <= 160) {
// heap_type = HEAP_160;
} else if (size >= MAX_STACK_OBJ) { } else if (size >= MAX_STACK_OBJ) {
h = hrt->huge_obj_heap;
heap_type = HEAP_HUGE; heap_type = HEAP_HUGE;
} else { } else {
h = hrt->heap;
heap_type = HEAP_REST; heap_type = HEAP_REST;
} }
h = hrt->heap[heap_type];
#if GC_DEBUG_TRACE #if GC_DEBUG_TRACE
allocated_heap_counts[heap_type]++; allocated_heap_counts[heap_type]++;
#endif #endif
@ -1050,8 +1053,14 @@ void gc_mut_cooperate(gc_thread_data * thd, int buf_len)
if (ck_pr_load_int(&gc_stage) == STAGE_RESTING && if (ck_pr_load_int(&gc_stage) == STAGE_RESTING &&
((cached_heap_free_sizes[HEAP_SM] < ((cached_heap_free_sizes[HEAP_SM] <
cached_heap_total_sizes[HEAP_SM] * GC_COLLECTION_THRESHOLD) || cached_heap_total_sizes[HEAP_SM] * GC_COLLECTION_THRESHOLD) ||
(cached_heap_free_sizes[HEAP_MED] < (cached_heap_free_sizes[HEAP_64] <
cached_heap_total_sizes[HEAP_MED] * GC_COLLECTION_THRESHOLD) || cached_heap_total_sizes[HEAP_64] * GC_COLLECTION_THRESHOLD) ||
(cached_heap_free_sizes[HEAP_96] <
cached_heap_total_sizes[HEAP_96] * GC_COLLECTION_THRESHOLD) ||
// (cached_heap_free_sizes[HEAP_128] <
// cached_heap_total_sizes[HEAP_128] * GC_COLLECTION_THRESHOLD) ||
// (cached_heap_free_sizes[HEAP_160] <
// cached_heap_total_sizes[HEAP_160] * GC_COLLECTION_THRESHOLD) ||
(cached_heap_free_sizes[HEAP_REST] < (cached_heap_free_sizes[HEAP_REST] <
cached_heap_total_sizes[HEAP_REST] * GC_COLLECTION_THRESHOLD))) { cached_heap_total_sizes[HEAP_REST] * GC_COLLECTION_THRESHOLD))) {
#if GC_DEBUG_TRACE #if GC_DEBUG_TRACE
@ -1392,14 +1401,11 @@ void gc_collector()
ck_pr_cas_int(&gc_stage, STAGE_TRACING, STAGE_SWEEPING); ck_pr_cas_int(&gc_stage, STAGE_TRACING, STAGE_SWEEPING);
// //
//sweep : //sweep :
gc_sweep(gc_get_heap()->heap, HEAP_REST, &freed_tmp);
freed += freed_tmp; for (heap_type = 0; heap_type < NUM_HEAP_TYPES; heap_type++) {
gc_sweep(gc_get_heap()->small_obj_heap, HEAP_SM, &freed_tmp); gc_sweep(gc_get_heap()->heap[heap_type], heap_type, &freed_tmp);
freed += freed_tmp;
gc_sweep(gc_get_heap()->medium_obj_heap, HEAP_MED, &freed_tmp);
freed += freed_tmp;
gc_sweep(gc_get_heap()->huge_obj_heap, HEAP_HUGE, &freed_tmp);
freed += freed_tmp; freed += freed_tmp;
}
// TODO: this loop only includes smallest 2 heaps, is that sufficient?? // TODO: this loop only includes smallest 2 heaps, is that sufficient??
for (heap_type = 0; heap_type < 2; heap_type++) { for (heap_type = 0; heap_type < 2; heap_type++) {
@ -1410,19 +1416,27 @@ void gc_collector()
100.0 * GC_FREE_THRESHOLD, heap_type); 100.0 * GC_FREE_THRESHOLD, heap_type);
#endif #endif
if (heap_type == HEAP_SM) { if (heap_type == HEAP_SM) {
gc_grow_heap(gc_get_heap()->small_obj_heap, heap_type, 0, 0); gc_grow_heap(gc_get_heap()->heap[heap_type], heap_type, 0, 0);
} else if (heap_type == HEAP_MED) { } else if (heap_type == HEAP_64) {
gc_grow_heap(gc_get_heap()->medium_obj_heap, heap_type, 0, 0); gc_grow_heap(gc_get_heap()->heap[heap_type], heap_type, 0, 0);
} else if (heap_type == HEAP_REST) { } else if (heap_type == HEAP_REST) {
gc_grow_heap(gc_get_heap()->heap, heap_type, 0, 0); gc_grow_heap(gc_get_heap()->heap[heap_type], heap_type, 0, 0);
} }
} }
} }
#if GC_DEBUG_TRACE #if GC_DEBUG_TRACE
total_size = cached_heap_total_sizes[HEAP_SM] + total_size = cached_heap_total_sizes[HEAP_SM] +
cached_heap_total_sizes[HEAP_MED] + cached_heap_total_sizes[HEAP_REST]; cached_heap_total_sizes[HEAP_64] +
cached_heap_total_sizes[HEAP_96] +
// cached_heap_total_sizes[HEAP_128] +
// cached_heap_total_sizes[HEAP_160] +
cached_heap_total_sizes[HEAP_REST];
total_free = cached_heap_free_sizes[HEAP_SM] + total_free = cached_heap_free_sizes[HEAP_SM] +
cached_heap_free_sizes[HEAP_MED] + cached_heap_free_sizes[HEAP_REST]; cached_heap_free_sizes[HEAP_64] +
cached_heap_free_sizes[HEAP_96] +
// cached_heap_free_sizes[HEAP_128] +
// cached_heap_free_sizes[HEAP_160] +
cached_heap_free_sizes[HEAP_REST];
fprintf(stderr, fprintf(stderr,
"sweep done, total_size = %zu, total_free = %zu, freed = %zu, elapsed = %ld\n", "sweep done, total_size = %zu, total_free = %zu, freed = %zu, elapsed = %ld\n",
total_size, total_free, freed, total_size, total_free, freed,

18
include/cyclone/types.h
View file

@ -156,17 +156,16 @@ struct gc_thread_data_t {
*/ */
typedef enum { typedef enum {
HEAP_SM = 0 // 32 byte objects (min gc_heap_align) HEAP_SM = 0 // 32 byte objects (min gc_heap_align)
, HEAP_MED // 64 byte objects (twice the min) , HEAP_64
// TODO: branch to car4-dev first! , HEAP_96
// TODO: replace above with: // , HEAP_128
//, HEAP_64 // , HEAP_160
//, HEAP_92
//, HEAP_128
//, HEAP_160
, HEAP_REST // Everything else , HEAP_REST // Everything else
, HEAP_HUGE // Huge objects, 1 per page , HEAP_HUGE // Huge objects, 1 per page
} gc_heap_type; } gc_heap_type;
#define NUM_HEAP_TYPES (HEAP_HUGE + 1)
typedef struct gc_free_list_t gc_free_list; typedef struct gc_free_list_t gc_free_list;
struct gc_free_list_t { struct gc_free_list_t {
unsigned int size; unsigned int size;
@ -188,10 +187,7 @@ struct gc_heap_t {
typedef struct gc_heap_root_t gc_heap_root; typedef struct gc_heap_root_t gc_heap_root;
struct gc_heap_root_t { struct gc_heap_root_t {
gc_heap *small_obj_heap; gc_heap **heap;
gc_heap *medium_obj_heap;
gc_heap *huge_obj_heap;
gc_heap *heap;
}; };
typedef struct gc_header_type_t gc_header_type; typedef struct gc_header_type_t gc_header_type;

12
runtime.c
View file

@ -210,10 +210,14 @@ void gc_init_heap(long heap_size)
{ {
size_t initial_heap_size = INITIAL_HEAP_SIZE; size_t initial_heap_size = INITIAL_HEAP_SIZE;
Cyc_heap = malloc(sizeof(gc_heap_root)); Cyc_heap = malloc(sizeof(gc_heap_root));
Cyc_heap->heap = gc_heap_create(HEAP_REST, initial_heap_size, 0, 0); Cyc_heap->heap = malloc(sizeof(gc_heap *) * NUM_HEAP_TYPES);
Cyc_heap->small_obj_heap = gc_heap_create(HEAP_SM, initial_heap_size, 0, 0); Cyc_heap->heap[HEAP_REST] = gc_heap_create(HEAP_REST, initial_heap_size, 0, 0);
Cyc_heap->medium_obj_heap = gc_heap_create(HEAP_MED, initial_heap_size, 0, 0); Cyc_heap->heap[HEAP_SM] = gc_heap_create(HEAP_SM, initial_heap_size, 0, 0);
Cyc_heap->huge_obj_heap = gc_heap_create(HEAP_HUGE, 1024, 0, 0); Cyc_heap->heap[HEAP_64] = gc_heap_create(HEAP_64, initial_heap_size, 0, 0);
Cyc_heap->heap[HEAP_96] = gc_heap_create(HEAP_96, initial_heap_size, 0, 0);
// Cyc_heap->heap[HEAP_128] = gc_heap_create(HEAP_128, initial_heap_size, 0, 0);
// Cyc_heap->heap[HEAP_160] = gc_heap_create(HEAP_160, initial_heap_size, 0, 0);
Cyc_heap->heap[HEAP_HUGE] = gc_heap_create(HEAP_HUGE, 1024, 0, 0);
if (!ck_hs_init(&symbol_table, if (!ck_hs_init(&symbol_table,
CK_HS_MODE_OBJECT | CK_HS_MODE_SPMC, CK_HS_MODE_OBJECT | CK_HS_MODE_SPMC,