Fcalva/cyclone
1
0
Fork 0
mirror of https://github.com/justinethier/cyclone.git synced 2025-05-25 13:05:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fixed up code so it builds now

Browse source
This commit is contained in:
Justin Ethier 2017-01-26 18:03:15 -05:00
parent 1078c5ff27
commit 54051ead86
3 changed files with 80 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

109
gc.c
View file

@ -209,8 +209,11 @@ void gc_free_old_thread_data()
pthread_mutex_unlock(&mutators_lock); pthread_mutex_unlock(&mutators_lock);
} }
/**
* Create a new heap page. The caller must hold the necessary locks.
*/
gc_heap *gc_heap_create(int heap_type, size_t size, size_t max_size, gc_heap *gc_heap_create(int heap_type, size_t size, size_t max_size,
size_t chunk_size) size_t chunk_size, gc_thread_data *thd)
{ {
gc_free_list *free, *next; gc_free_list *free, *next;
gc_heap *h; gc_heap *h;
@ -224,8 +227,8 @@ gc_heap *gc_heap_create(int heap_type, size_t size, size_t max_size,
h->next_free = h; h->next_free = h;
h->last_alloc_size = 0; h->last_alloc_size = 0;
//h->free_size = size; //h->free_size = size;
ck_pr_add_64(&(cached_heap_total_sizes[heap_type]), size); ck_pr_add_64(&(thd->cached_heap_total_sizes[heap_type]), size);
ck_pr_add_64(&(cached_heap_free_sizes[heap_type]), size); ck_pr_add_64(&(thd->cached_heap_free_sizes[heap_type]), size);
h->chunk_size = chunk_size; h->chunk_size = chunk_size;
h->max_size = max_size; h->max_size = max_size;
h->data = (char *)gc_heap_align(sizeof(h->data) + (uintptr_t) & (h->data)); h->data = (char *)gc_heap_align(sizeof(h->data) + (uintptr_t) & (h->data));
@ -472,11 +475,11 @@ char *gc_copy_obj(object dest, char *obj, gc_thread_data * thd)
return (char *)obj; return (char *)obj;
} }
int gc_grow_heap(gc_heap * h, int heap_type, size_t size, size_t chunk_size) int gc_grow_heap(gc_heap * h, int heap_type, size_t size, size_t chunk_size, gc_thread_data *thd)
{ {
size_t /*cur_size,*/ new_size; size_t /*cur_size,*/ new_size;
gc_heap *h_last = h, *h_new; gc_heap *h_last = h, *h_new;
pthread_mutex_lock(&heap_lock); pthread_mutex_lock(&(thd->lock)); //heap_lock);
// Compute size of new heap page // Compute size of new heap page
if (heap_type == HEAP_HUGE) { if (heap_type == HEAP_HUGE) {
new_size = gc_heap_align(size) + 128; new_size = gc_heap_align(size) + 128;
@ -517,9 +520,9 @@ int gc_grow_heap(gc_heap * h, int heap_type, size_t size, size_t chunk_size)
// allocate larger pages if size will not fit on the page // allocate larger pages if size will not fit on the page
//new_size = gc_heap_align(((cur_size > size) ? cur_size : size)); //new_size = gc_heap_align(((cur_size > size) ? cur_size : size));
// Done with computing new page size // Done with computing new page size
h_new = gc_heap_create(heap_type, new_size, h_last->max_size, chunk_size); h_new = gc_heap_create(heap_type, new_size, h_last->max_size, chunk_size, thd);
h_last->next = h_new; h_last->next = h_new;
pthread_mutex_unlock(&heap_lock); pthread_mutex_unlock(&(thd->lock)); //heap_lock);
#if GC_DEBUG_TRACE #if GC_DEBUG_TRACE
fprintf(stderr, "DEBUG - grew heap\n"); fprintf(stderr, "DEBUG - grew heap\n");
#endif #endif
@ -531,7 +534,7 @@ void *gc_try_alloc(gc_heap * h, int heap_type, size_t size, char *obj,
{ {
gc_heap *h_passed = h; gc_heap *h_passed = h;
gc_free_list *f1, *f2, *f3; gc_free_list *f1, *f2, *f3;
pthread_mutex_lock(&heap_lock); pthread_mutex_lock(&(thd->lock)); //heap_lock);
// Start searching from the last heap page we had a successful // Start searching from the last heap page we had a successful
// allocation from, unless the current request is for a smaller // allocation from, unless the current request is for a smaller
// block in which case there may be available memory closer to // block in which case there may be available memory closer to
@ -558,17 +561,17 @@ void *gc_try_alloc(gc_heap * h, int heap_type, size_t size, char *obj,
// Copy object into heap now to avoid any uninitialized memory issues // Copy object into heap now to avoid any uninitialized memory issues
gc_copy_obj(f2, obj, thd); gc_copy_obj(f2, obj, thd);
//h->free_size -= gc_allocated_bytes(obj, NULL, NULL); //h->free_size -= gc_allocated_bytes(obj, NULL, NULL);
ck_pr_sub_64(&(cached_heap_free_sizes[heap_type]), ck_pr_sub_64(&(thd->cached_heap_free_sizes[heap_type]),
gc_allocated_bytes(obj, NULL, NULL)); gc_allocated_bytes(obj, NULL, NULL));
} }
h_passed->next_free = h; h_passed->next_free = h;
h_passed->last_alloc_size = size; h_passed->last_alloc_size = size;
pthread_mutex_unlock(&heap_lock); pthread_mutex_unlock(&(thd->lock)); //heap_lock);
return f2; return f2;
} }
} }
} }
pthread_mutex_unlock(&heap_lock); pthread_mutex_unlock(&(thd->lock)); //heap_lock);
return NULL; return NULL;
} }
@ -608,15 +611,15 @@ void *gc_alloc(gc_heap_root * hrt, size_t size, char *obj, gc_thread_data * thd,
// A vanilla mark&sweep collector would collect now, but unfortunately // A vanilla mark&sweep collector would collect now, but unfortunately
// we can't do that because we have to go through multiple stages, some // we can't do that because we have to go through multiple stages, some
// of which are asynchronous. So... no choice but to grow the heap. // of which are asynchronous. So... no choice but to grow the heap.
gc_grow_heap(h, heap_type, size, 0); gc_grow_heap(h, heap_type, size, 0, thd);
*heap_grown = 1; *heap_grown = 1;
result = gc_try_alloc(h, heap_type, size, obj, thd); result = gc_try_alloc(h, heap_type, size, obj, thd);
if (!result) { if (!result) {
fprintf(stderr, "out of memory error allocating %zu bytes\n", size); fprintf(stderr, "out of memory error allocating %zu bytes\n", size);
fprintf(stderr, "Heap type %d diagnostics:\n", heap_type); fprintf(stderr, "Heap type %d diagnostics:\n", heap_type);
pthread_mutex_lock(&heap_lock); pthread_mutex_lock(&(thd->lock)); //heap_lock);
gc_print_stats(h); gc_print_stats(h);
pthread_mutex_unlock(&heap_lock); // why not pthread_mutex_unlock(&(thd->lock)); //heap_lock); // why not
exit(1); // could throw error, but OOM is a major issue, so... exit(1); // could throw error, but OOM is a major issue, so...
} }
} }
@ -695,18 +698,18 @@ gc_heap *gc_heap_last(gc_heap * h)
return h; return h;
} }
size_t gc_heap_total_size(gc_heap * h) //size_t gc_heap_total_size(gc_heap * h)
{ //{
size_t total_size = 0; // size_t total_size = 0;
pthread_mutex_lock(&heap_lock); // pthread_mutex_lock(&heap_lock);
while (h) { // while (h) {
total_size += h->size; // total_size += h->size;
h = h->next; // h = h->next;
} // }
pthread_mutex_unlock(&heap_lock); // pthread_mutex_unlock(&heap_lock);
return total_size; // return total_size;
} //}
//
//size_t gc_heap_total_free_size(gc_heap *h) //size_t gc_heap_total_free_size(gc_heap *h)
//{ //{
// size_t total_size = 0; // size_t total_size = 0;
@ -737,7 +740,7 @@ void gc_collector_sweep()
for (heap_type = 0; heap_type < NUM_HEAP_TYPES; heap_type++) { for (heap_type = 0; heap_type < NUM_HEAP_TYPES; heap_type++) {
h = m->heap->heap[heap_type]; h = m->heap->heap[heap_type];
if (h) { if (h) {
gc_sweep(h, heap_type, &freed_tmp); gc_sweep(h, heap_type, &freed_tmp, m);
freed += freed_tmp; freed += freed_tmp;
} }
} }
@ -751,11 +754,11 @@ void gc_collector_sweep()
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(m->heap->heap[heap_type], heap_type, 0, 0); gc_grow_heap(m->heap->heap[heap_type], heap_type, 0, 0, m);
} else if (heap_type == HEAP_64) { } else if (heap_type == HEAP_64) {
gc_grow_heap(m->heap->heap[heap_type], heap_type, 0, 0); gc_grow_heap(m->heap->heap[heap_type], heap_type, 0, 0, m);
} else if (heap_type == HEAP_REST) { } else if (heap_type == HEAP_REST) {
gc_grow_heap(m->heap->heap[heap_type], heap_type, 0, 0); gc_grow_heap(m->heap->heap[heap_type], heap_type, 0, 0, m);
} }
} }
} }
@ -783,7 +786,7 @@ void gc_collector_sweep()
#endif #endif
} }
size_t gc_sweep(gc_heap * h, int heap_type, size_t * sum_freed_ptr) size_t gc_sweep(gc_heap * h, int heap_type, size_t * sum_freed_ptr, gc_thread_data *thd)
{ {
size_t freed, max_freed = 0, heap_freed = 0, sum_freed = 0, size; size_t freed, max_freed = 0, heap_freed = 0, sum_freed = 0, size;
object p, end; object p, end;
@ -801,7 +804,7 @@ size_t gc_sweep(gc_heap * h, int heap_type, size_t * sum_freed_ptr)
// by using more fine-grained locking. Can also profile to see // by using more fine-grained locking. Can also profile to see
// how much time is even spent sweeping // how much time is even spent sweeping
// //
pthread_mutex_lock(&heap_lock); pthread_mutex_lock(&(thd->lock)); //heap_lock);
h->next_free = h; h->next_free = h;
h->last_alloc_size = 0; h->last_alloc_size = 0;
@ -909,7 +912,7 @@ size_t gc_sweep(gc_heap * h, int heap_type, size_t * sum_freed_ptr)
} }
} }
//h->free_size += heap_freed; //h->free_size += heap_freed;
ck_pr_add_64(&(cached_heap_free_sizes[heap_type]), heap_freed); ck_pr_add_64(&(thd->cached_heap_free_sizes[heap_type]), heap_freed);
// Free the heap page if possible. // Free the heap page if possible.
// //
// With huge heaps, this becomes more important. one of the huge // With huge heaps, this becomes more important. one of the huge
@ -928,8 +931,8 @@ size_t gc_sweep(gc_heap * h, int heap_type, size_t * sum_freed_ptr)
(h->type == HEAP_HUGE || !(h->ttl--))) { (h->type == HEAP_HUGE || !(h->ttl--))) {
unsigned int h_size = h->size; unsigned int h_size = h->size;
h = gc_heap_free(h, prev_h); h = gc_heap_free(h, prev_h);
ck_pr_sub_64(&(cached_heap_free_sizes[heap_type] ), h_size); ck_pr_sub_64(&(thd->cached_heap_free_sizes[heap_type] ), h_size);
ck_pr_sub_64(&(cached_heap_total_sizes[heap_type]), h_size); ck_pr_sub_64(&(thd->cached_heap_total_sizes[heap_type]), h_size);
} }
sum_freed += heap_freed; sum_freed += heap_freed;
@ -942,7 +945,7 @@ size_t gc_sweep(gc_heap * h, int heap_type, size_t * sum_freed_ptr)
gc_print_stats(orig_heap_ptr); gc_print_stats(orig_heap_ptr);
#endif #endif
pthread_mutex_unlock(&heap_lock); pthread_mutex_unlock(&(thd->lock)); //heap_lock);
if (sum_freed_ptr) if (sum_freed_ptr)
*sum_freed_ptr = sum_freed; *sum_freed_ptr = sum_freed;
return max_freed; return max_freed;
@ -1143,16 +1146,16 @@ void gc_mut_cooperate(gc_thread_data * thd, int buf_len)
// Threshold is intentially low because we have to go through an // Threshold is intentially low because we have to go through an
// entire handshake/trace/sweep cycle, ideally without growing heap. // entire handshake/trace/sweep cycle, ideally without growing heap.
if (ck_pr_load_int(&gc_stage) == STAGE_RESTING && if (ck_pr_load_int(&gc_stage) == STAGE_RESTING &&
((ck_pr_load_64(&(cached_heap_free_sizes[HEAP_SM])) < ((ck_pr_load_64(&(thd->cached_heap_free_sizes[HEAP_SM])) <
ck_pr_load_64(&(cached_heap_total_sizes[HEAP_SM])) * GC_COLLECTION_THRESHOLD) || ck_pr_load_64(&(thd->cached_heap_total_sizes[HEAP_SM])) * GC_COLLECTION_THRESHOLD) ||
(ck_pr_load_64(&(cached_heap_free_sizes[HEAP_64])) < (ck_pr_load_64(&(thd->cached_heap_free_sizes[HEAP_64])) <
ck_pr_load_64(&(cached_heap_total_sizes[HEAP_64])) * GC_COLLECTION_THRESHOLD) || ck_pr_load_64(&(thd->cached_heap_total_sizes[HEAP_64])) * GC_COLLECTION_THRESHOLD) ||
#if INTPTR_MAX == INT64_MAX #if INTPTR_MAX == INT64_MAX
(ck_pr_load_64(&(cached_heap_free_sizes[HEAP_96])) < (ck_pr_load_64(&(thd->cached_heap_free_sizes[HEAP_96])) <
ck_pr_load_64(&(cached_heap_total_sizes[HEAP_96])) * GC_COLLECTION_THRESHOLD) || ck_pr_load_64(&(thd->cached_heap_total_sizes[HEAP_96])) * GC_COLLECTION_THRESHOLD) ||
#endif #endif
(ck_pr_load_64(&(cached_heap_free_sizes[HEAP_REST])) < (ck_pr_load_64(&(thd->cached_heap_free_sizes[HEAP_REST])) <
ck_pr_load_64(&(cached_heap_total_sizes[HEAP_REST])) * GC_COLLECTION_THRESHOLD))) { ck_pr_load_64(&(thd->cached_heap_total_sizes[HEAP_REST])) * GC_COLLECTION_THRESHOLD))) {
#if GC_DEBUG_TRACE #if GC_DEBUG_TRACE
fprintf(stderr, fprintf(stderr,
"Less than %f%% of the heap is free, initiating collector\n", "Less than %f%% of the heap is free, initiating collector\n",
@ -1664,17 +1667,17 @@ void gc_thread_data_init(gc_thread_data * thd, int mut_num, char *stack_base,
fprintf(stderr, "Unable to initialize thread mutex\n"); fprintf(stderr, "Unable to initialize thread mutex\n");
exit(1); exit(1);
} }
thd->heap = calloc(1, sizeof(gc_heap_root));
thd->heap->heap = calloc(1, sizeof(gc_heap *) * NUM_HEAP_TYPES);
thd->heap->heap[HEAP_REST] = gc_heap_create(HEAP_REST, INITIAL_HEAP_SIZE, 0, 0);
thd->heap->heap[HEAP_SM] = gc_heap_create(HEAP_SM, INITIAL_HEAP_SIZE, 0, 0);
thd->heap->heap[HEAP_64] = gc_heap_create(HEAP_64, INITIAL_HEAP_SIZE, 0, 0);
if (sizeof(void *) == 8) { // Only use this heap on 64-bit platforms
thd->heap->heap[HEAP_96] = gc_heap_create(HEAP_96, INITIAL_HEAP_SIZE, 0, 0);
}
thd->heap->heap[HEAP_HUGE] = gc_heap_create(HEAP_HUGE, 1024, 0, 0);
thd->cached_heap_free_sizes = calloc(5, sizeof(uint64_t)); thd->cached_heap_free_sizes = calloc(5, sizeof(uint64_t));
thd->cached_heap_total_sizes = calloc(5, sizeof(uint64_t)); thd->cached_heap_total_sizes = calloc(5, sizeof(uint64_t));
thd->heap = calloc(1, sizeof(gc_heap_root));
thd->heap->heap = calloc(1, sizeof(gc_heap *) * NUM_HEAP_TYPES);
thd->heap->heap[HEAP_REST] = gc_heap_create(HEAP_REST, INITIAL_HEAP_SIZE, 0, 0, thd);
thd->heap->heap[HEAP_SM] = gc_heap_create(HEAP_SM, INITIAL_HEAP_SIZE, 0, 0, thd);
thd->heap->heap[HEAP_64] = gc_heap_create(HEAP_64, INITIAL_HEAP_SIZE, 0, 0, thd);
if (sizeof(void *) == 8) { // Only use this heap on 64-bit platforms
thd->heap->heap[HEAP_96] = gc_heap_create(HEAP_96, INITIAL_HEAP_SIZE, 0, 0, thd);
}
thd->heap->heap[HEAP_HUGE] = gc_heap_create(HEAP_HUGE, 1024, 0, 0, thd);
} }
void gc_thread_data_free(gc_thread_data * thd) void gc_thread_data_free(gc_thread_data * thd)

6
include/cyclone/types.h
View file

@ -660,10 +660,10 @@ void gc_initialize();
void gc_add_mutator(gc_thread_data * thd); void gc_add_mutator(gc_thread_data * thd);
void gc_remove_mutator(gc_thread_data * thd); void gc_remove_mutator(gc_thread_data * thd);
gc_heap *gc_heap_create(int heap_type, size_t size, size_t max_size, gc_heap *gc_heap_create(int heap_type, size_t size, size_t max_size,
size_t chunk_size); size_t chunk_size, gc_thread_data *thd);
gc_heap *gc_heap_free(gc_heap *page, gc_heap *prev_page); gc_heap *gc_heap_free(gc_heap *page, gc_heap *prev_page);
void gc_print_stats(gc_heap * h); void gc_print_stats(gc_heap * h);
int gc_grow_heap(gc_heap * h, int heap_type, size_t size, size_t chunk_size); int gc_grow_heap(gc_heap * h, int heap_type, size_t size, size_t chunk_size, gc_thread_data *thd);
char *gc_copy_obj(object hp, char *obj, gc_thread_data * thd); char *gc_copy_obj(object hp, char *obj, gc_thread_data * thd);
void *gc_try_alloc(gc_heap * h, int heap_type, size_t size, char *obj, void *gc_try_alloc(gc_heap * h, int heap_type, size_t size, char *obj,
gc_thread_data * thd); gc_thread_data * thd);
@ -677,7 +677,7 @@ size_t gc_heap_total_size(gc_heap * h);
//void gc_mark(gc_heap *h, object obj); //void gc_mark(gc_heap *h, object obj);
void gc_request_mark_globals(void); void gc_request_mark_globals(void);
void gc_mark_globals(object globals, object global_table); void gc_mark_globals(object globals, object global_table);
size_t gc_sweep(gc_heap * h, int heap_type, size_t * sum_freed_ptr); size_t gc_sweep(gc_heap * h, int heap_type, size_t * sum_freed_ptr, gc_thread_data *thd);
void gc_thr_grow_move_buffer(gc_thread_data * d); void gc_thr_grow_move_buffer(gc_thread_data * d);
void gc_thr_add_to_move_buffer(gc_thread_data * d, int *alloci, object obj); void gc_thr_add_to_move_buffer(gc_thread_data * d, int *alloci, object obj);
void gc_thread_data_init(gc_thread_data * thd, int mut_num, char *stack_base, void gc_thread_data_init(gc_thread_data * thd, int mut_num, char *stack_base,

15
runtime.c
View file

@ -2046,12 +2046,27 @@ object Cyc_make_bytevector(void *data, object cont, int argc, object len, ...)
Cyc_check_num(data, len); Cyc_check_num(data, len);
length = unbox_number(len); length = unbox_number(len);
if (length >= MAX_STACK_OBJ) {
int heap_grown;
bv = gc_alloc(((gc_thread_data *)data)->heap,
sizeof(bytevector_type) + length,
boolean_f, // OK to populate manually over here
(gc_thread_data *)data,
&heap_grown);
((bytevector) bv)->hdr.mark = ((gc_thread_data *)data)->gc_alloc_color;
((bytevector) bv)->hdr.grayed = 0;
((bytevector) bv)->tag = bytevector_tag;
((bytevector) bv)->len = length;
((bytevector) bv)->data = (char *)(((char *)bv) + sizeof(bytevector_type));
} else {
bv = alloca(sizeof(bytevector_type)); bv = alloca(sizeof(bytevector_type));
((bytevector) bv)->hdr.mark = gc_color_red; ((bytevector) bv)->hdr.mark = gc_color_red;
((bytevector) bv)->hdr.grayed = 0; ((bytevector) bv)->hdr.grayed = 0;
((bytevector) bv)->tag = bytevector_tag; ((bytevector) bv)->tag = bytevector_tag;
((bytevector) bv)->len = length; ((bytevector) bv)->len = length;
((bytevector) bv)->data = alloca(sizeof(char) * length); ((bytevector) bv)->data = alloca(sizeof(char) * length);
}
if (argc > 1) { if (argc > 1) {
Cyc_check_num(data, fill); Cyc_check_num(data, fill);
fill_val = unbox_number(fill); fill_val = unbox_number(fill);