#include #include #include #include #include "gc-api.h" #define GC_IMPL 1 #include "gc-internal.h" #include "gc-platform.h" #include "gc-tracepoint.h" #include "heap-sizer.h" #include "semi-attrs.h" #include "large-object-space.h" #if GC_CONSERVATIVE_ROOTS #error semi is a precise collector #endif struct gc_options { struct gc_common_options common; }; struct region { uintptr_t base; size_t active_size; size_t mapped_size; }; struct semi_space { uintptr_t hp; uintptr_t limit; struct region from_space; struct region to_space; size_t page_size; size_t stolen_pages; size_t live_bytes_at_last_gc; }; struct gc_heap { struct semi_space semi_space; struct large_object_space large_object_space; struct gc_pending_ephemerons *pending_ephemerons; struct gc_finalizer_state *finalizer_state; struct gc_extern_space *extern_space; double pending_ephemerons_size_factor; double pending_ephemerons_size_slop; size_t size; size_t total_allocated_bytes_at_last_gc; long count; int check_pending_ephemerons; const struct gc_options *options; struct gc_heap_roots *roots; struct gc_heap_sizer sizer; struct gc_event_listener event_listener; void *event_listener_data; void* (*allocation_failure)(struct gc_heap *, size_t); }; // One mutator per space, can just store the heap in the mutator. struct gc_mutator { struct gc_heap heap; struct gc_mutator_roots *roots; void *event_listener_data; }; #define HEAP_EVENT(heap, event, ...) do { \ (heap)->event_listener.event((heap)->event_listener_data, ##__VA_ARGS__); \ GC_TRACEPOINT(event, ##__VA_ARGS__); \ } while (0) #define MUTATOR_EVENT(mut, event, ...) do { \ (mut)->heap->event_listener.event((mut)->event_listener_data, \ ##__VA_ARGS__); \ GC_TRACEPOINT(event, ##__VA_ARGS__); \ } while (0) static inline void clear_memory(uintptr_t addr, size_t size) { memset((char*)addr, 0, size); } static inline struct gc_heap* mutator_heap(struct gc_mutator *mut) { return &mut->heap; } static inline struct semi_space* heap_semi_space(struct gc_heap *heap) { return &heap->semi_space; } static inline struct large_object_space* heap_large_object_space(struct gc_heap *heap) { return &heap->large_object_space; } static inline struct semi_space* mutator_semi_space(struct gc_mutator *mut) { return heap_semi_space(mutator_heap(mut)); } struct gc_heap* gc_mutator_heap(struct gc_mutator *mutator) { return mutator_heap(mutator); } uintptr_t gc_small_object_nursery_low_address(struct gc_heap *heap) { GC_CRASH(); } uintptr_t gc_small_object_nursery_high_address(struct gc_heap *heap) { GC_CRASH(); } static uintptr_t align_up(uintptr_t addr, size_t align) { return (addr + align - 1) & ~(align-1); } static size_t min_size(size_t a, size_t b) { return a < b ? a : b; } static size_t max_size(size_t a, size_t b) { return a < b ? b : a; } static void collect(struct gc_mutator *mut) GC_NEVER_INLINE; static int collect_for_alloc(struct gc_mutator *mut, size_t bytes) GC_NEVER_INLINE; static void trace(struct gc_edge edge, struct gc_heap *heap, void *visit_data); static void region_trim_by(struct region *region, size_t newly_unavailable) { size_t old_available = region->active_size; GC_ASSERT(newly_unavailable <= region->active_size); region->active_size -= newly_unavailable; gc_platform_discard_memory((void*)(region->base + region->active_size), newly_unavailable); } static void region_set_active_size(struct region *region, size_t size) { GC_ASSERT(size <= region->mapped_size); GC_ASSERT(size == align_up(size, gc_platform_page_size())); if (size < region->active_size) region_trim_by(region, region->active_size - size); else region->active_size = size; } static int semi_space_steal_pages(struct semi_space *space, size_t npages) { size_t old_stolen_pages = space->stolen_pages; size_t old_region_stolen_pages = align_up(old_stolen_pages,2)/2; size_t new_stolen_pages = old_stolen_pages + npages; size_t new_region_stolen_pages = align_up(new_stolen_pages,2)/2; size_t region_newly_stolen_pages = new_region_stolen_pages - old_region_stolen_pages; size_t region_newly_unavailable_bytes = region_newly_stolen_pages * space->page_size; if (space->limit - space->hp < region_newly_unavailable_bytes) return 0; space->stolen_pages += npages; if (region_newly_unavailable_bytes == 0) return 1; space->limit -= region_newly_unavailable_bytes; region_trim_by(&space->to_space, region_newly_unavailable_bytes); region_trim_by(&space->from_space, region_newly_unavailable_bytes); return 1; } static void semi_space_finish_gc(struct semi_space *space, size_t large_object_pages) { space->live_bytes_at_last_gc = space->hp - space->to_space.base; space->stolen_pages = large_object_pages; space->limit = 0; // set in adjust_heap_size_and_limits } static void semi_space_add_to_allocation_counter(struct semi_space *space, uint64_t *counter) { size_t base = space->to_space.base + space->live_bytes_at_last_gc; *counter += space->hp - base; } static void flip(struct semi_space *space) { struct region tmp; GC_ASSERT(space->hp <= space->limit); GC_ASSERT(space->limit - space->to_space.base <= space->to_space.active_size); GC_ASSERT(space->to_space.active_size <= space->from_space.mapped_size); memcpy(&tmp, &space->from_space, sizeof(tmp)); memcpy(&space->from_space, &space->to_space, sizeof(tmp)); memcpy(&space->to_space, &tmp, sizeof(tmp)); space->hp = space->to_space.base; space->limit = space->hp + space->to_space.active_size; } static struct gc_ref copy(struct gc_heap *heap, struct semi_space *space, struct gc_ref ref) { size_t size; gc_trace_object(ref, NULL, NULL, NULL, &size); struct gc_ref new_ref = gc_ref(space->hp); memcpy(gc_ref_heap_object(new_ref), gc_ref_heap_object(ref), size); gc_object_forward_nonatomic(ref, new_ref); space->hp += align_up(size, GC_ALIGNMENT); if (GC_UNLIKELY(heap->check_pending_ephemerons)) gc_resolve_pending_ephemerons(ref, heap); return new_ref; } static uintptr_t scan(struct gc_heap *heap, struct gc_ref grey) { size_t size; gc_trace_object(grey, trace, heap, NULL, &size); return gc_ref_value(grey) + align_up(size, GC_ALIGNMENT); } static struct gc_ref forward(struct gc_heap *heap, struct semi_space *space, struct gc_ref obj) { uintptr_t forwarded = gc_object_forwarded_nonatomic(obj); return forwarded ? gc_ref(forwarded) : copy(heap, space, obj); } static void visit_semi_space(struct gc_heap *heap, struct semi_space *space, struct gc_edge edge, struct gc_ref ref) { gc_edge_update(edge, forward(heap, space, ref)); } static void visit_large_object_space(struct gc_heap *heap, struct large_object_space *space, struct gc_ref ref) { if (large_object_space_mark(space, ref)) { if (GC_UNLIKELY(heap->check_pending_ephemerons)) gc_resolve_pending_ephemerons(ref, heap); gc_trace_object(ref, trace, heap, NULL, NULL); } } static int region_contains(struct region *region, uintptr_t addr) { return addr - region->base < region->active_size; } static int semi_space_contains(struct semi_space *space, struct gc_ref ref) { // As each live object is traced exactly once, its edges have not been // visited, so its refs are to fromspace and not tospace. uintptr_t addr = gc_ref_value(ref); GC_ASSERT(!region_contains(&space->to_space, addr)); return region_contains(&space->from_space, addr); } static void visit_external_object(struct gc_heap *heap, struct gc_extern_space *space, struct gc_edge edge, struct gc_ref old_ref) { if (gc_extern_space_visit(space, edge, old_ref)) { if (GC_UNLIKELY(heap->check_pending_ephemerons)) gc_resolve_pending_ephemerons(old_ref, heap); gc_trace_object(gc_edge_ref(edge), trace, heap, NULL, NULL); } } static void visit(struct gc_edge edge, struct gc_heap *heap) { struct gc_ref ref = gc_edge_ref(edge); if (gc_ref_is_null(ref) || gc_ref_is_immediate(ref)) return; if (semi_space_contains(heap_semi_space(heap), ref)) visit_semi_space(heap, heap_semi_space(heap), edge, ref); else if (large_object_space_contains_with_lock(heap_large_object_space(heap), ref)) visit_large_object_space(heap, heap_large_object_space(heap), ref); else visit_external_object(heap, heap->extern_space, edge, ref); } struct gc_pending_ephemerons * gc_heap_pending_ephemerons(struct gc_heap *heap) { return heap->pending_ephemerons; } int gc_visit_ephemeron_key(struct gc_edge edge, struct gc_heap *heap) { struct gc_ref ref = gc_edge_ref(edge); GC_ASSERT(!gc_ref_is_null(ref)); if (gc_ref_is_immediate(ref)) return 1; GC_ASSERT(gc_ref_is_heap_object(ref)); if (semi_space_contains(heap_semi_space(heap), ref)) { uintptr_t forwarded = gc_object_forwarded_nonatomic(ref); if (!forwarded) return 0; gc_edge_update(edge, gc_ref(forwarded)); return 1; } else if (large_object_space_contains_with_lock(heap_large_object_space(heap), ref)) { return large_object_space_is_marked(heap_large_object_space(heap), ref); } GC_CRASH(); } static void trace(struct gc_edge edge, struct gc_heap *heap, void *visit_data) { return visit(edge, heap); } static int grow_region_if_needed(struct region *region, size_t new_size) { if (new_size <= region->mapped_size) return 1; void *mem = gc_platform_acquire_memory(new_size, 0); DEBUG("new size %zx\n", new_size); if (!mem) return 0; if (region->mapped_size) gc_platform_release_memory((void*)region->base, region->mapped_size); region->base = (uintptr_t)mem; region->active_size = 0; region->mapped_size = new_size; return 1; } static void truncate_region(struct region *region, size_t new_size) { GC_ASSERT(new_size <= region->mapped_size); size_t bytes = region->mapped_size - new_size; if (bytes) { gc_platform_release_memory((void*)(region->base + new_size), bytes); region->mapped_size = new_size; if (region->active_size > new_size) region->active_size = new_size; } } static void resize_heap(struct gc_heap *heap, size_t new_heap_size) { struct semi_space *semi = heap_semi_space(heap); new_heap_size = align_up(new_heap_size, semi->page_size * 2); size_t new_region_size = new_heap_size / 2; // Note that there is an asymmetry in how heap size is adjusted: we // grow in two cycles (first the fromspace, then the tospace after it // becomes the fromspace in the next collection) but shrink in one (by // returning pages to the OS). // If we are growing the heap now, grow the fromspace mapping. Also, // always try to grow the fromspace if it is smaller than the tospace. grow_region_if_needed(&semi->from_space, max_size(new_region_size, semi->to_space.mapped_size)); // We may have grown fromspace. Find out what our actual new region // size will be. new_region_size = min_size(new_region_size, min_size(semi->to_space.mapped_size, semi->from_space.mapped_size)); size_t old_heap_size = heap->size; heap->size = new_region_size * 2; if (heap->size != old_heap_size) HEAP_EVENT(heap, heap_resized, heap->size); } static void reset_heap_limits(struct gc_heap *heap) { struct semi_space *semi = heap_semi_space(heap); size_t new_region_size = align_up(heap->size, semi->page_size * 2) / 2; size_t stolen = align_up(semi->stolen_pages, 2) * semi->page_size; GC_ASSERT(new_region_size > stolen/2); size_t new_active_region_size = new_region_size - stolen/2; region_set_active_size(&semi->from_space, new_active_region_size); region_set_active_size(&semi->to_space, new_active_region_size); size_t new_limit = semi->to_space.base + new_active_region_size; GC_ASSERT(semi->hp <= new_limit); semi->limit = new_limit; } static uintptr_t trace_closure(struct gc_heap *heap, struct semi_space *semi, uintptr_t grey) { while(grey < semi->hp) grey = scan(heap, gc_ref(grey)); return grey; } static uintptr_t resolve_ephemerons(struct gc_heap *heap, uintptr_t grey) { for (struct gc_ephemeron *resolved = gc_pop_resolved_ephemerons(heap); resolved; resolved = gc_pop_resolved_ephemerons(heap)) { gc_trace_resolved_ephemerons(resolved, trace, heap, NULL); grey = trace_closure(heap, heap_semi_space(heap), grey); } return grey; } static uintptr_t resolve_finalizers(struct gc_heap *heap, uintptr_t grey) { for (size_t priority = 0; priority < gc_finalizer_priority_count(); priority++) { if (gc_resolve_finalizers(heap->finalizer_state, priority, trace, heap, NULL)) { grey = trace_closure(heap, heap_semi_space(heap), grey); grey = resolve_ephemerons(heap, grey); } } gc_notify_finalizers(heap->finalizer_state, heap); return grey; } static void collect(struct gc_mutator *mut) { struct gc_heap *heap = mutator_heap(mut); int is_minor = 0; int is_compacting = 1; uint64_t start_ns = gc_platform_monotonic_nanoseconds(); HEAP_EVENT(heap, requesting_stop); HEAP_EVENT(heap, waiting_for_stop); HEAP_EVENT(heap, mutators_stopped); HEAP_EVENT(heap, prepare_gc, GC_COLLECTION_COMPACTING); struct semi_space *semi = heap_semi_space(heap); struct large_object_space *large = heap_large_object_space(heap); // fprintf(stderr, "start collect #%ld:\n", space->count); uint64_t *counter_loc = &heap->total_allocated_bytes_at_last_gc; semi_space_add_to_allocation_counter(semi, counter_loc); large_object_space_add_to_allocation_counter(large, counter_loc); large_object_space_start_gc(large, 0); gc_extern_space_start_gc(heap->extern_space, 0); flip(semi); heap->count++; heap->check_pending_ephemerons = 0; uintptr_t grey = semi->hp; if (heap->roots) gc_trace_heap_roots(heap->roots, trace, heap, NULL); if (mut->roots) gc_trace_mutator_roots(mut->roots, trace, heap, NULL); gc_visit_finalizer_roots(heap->finalizer_state, trace, heap, NULL); HEAP_EVENT(heap, roots_traced); // fprintf(stderr, "pushed %zd bytes in roots\n", space->hp - grey); grey = trace_closure(heap, semi, grey); HEAP_EVENT(heap, heap_traced); gc_scan_pending_ephemerons(heap->pending_ephemerons, heap, 0, 1); heap->check_pending_ephemerons = 1; grey = resolve_ephemerons(heap, grey); HEAP_EVENT(heap, ephemerons_traced); grey = resolve_finalizers(heap, grey); HEAP_EVENT(heap, finalizers_traced); large_object_space_finish_gc(large, 0); gc_extern_space_finish_gc(heap->extern_space, 0); semi_space_finish_gc(semi, large->live_pages_at_last_collection); gc_sweep_pending_ephemerons(heap->pending_ephemerons, 0, 1); size_t live_size = semi->live_bytes_at_last_gc; live_size += large_object_space_size_at_last_collection(large); uint64_t pause_ns = gc_platform_monotonic_nanoseconds() - start_ns; HEAP_EVENT(heap, live_data_size, live_size); DEBUG("gc %zu: live size %zu, heap size %zu\n", heap->count, live_size, heap->size); gc_heap_sizer_on_gc(heap->sizer, heap->size, live_size, pause_ns, resize_heap); reset_heap_limits(heap); clear_memory(semi->hp, semi->limit - semi->hp); HEAP_EVENT(heap, restarting_mutators); // fprintf(stderr, "%zd bytes copied\n", (space->size>>1)-(space->limit-space->hp)); } static int collect_for_alloc(struct gc_mutator *mut, size_t bytes) { collect(mut); struct semi_space *space = mutator_semi_space(mut); if (bytes <= space->limit - space->hp) return 1; struct gc_heap *heap = mutator_heap(mut); if (heap->options->common.heap_size_policy != GC_HEAP_SIZE_FIXED) { // Each collection can potentially resize only the inactive // fromspace, so if we really run out of space we will need to // collect again in order to resize the other half. collect(mut); if (bytes <= space->limit - space->hp) return 1; } return 0; } void gc_collect(struct gc_mutator *mut, enum gc_collection_kind requested_kind) { // Ignore requested kind, because we always compact. collect(mut); } int gc_heap_contains(struct gc_heap *heap, struct gc_ref ref) { GC_ASSERT(gc_ref_is_heap_object(ref)); return semi_space_contains(heap_semi_space(heap), ref) || large_object_space_contains(heap_large_object_space(heap), ref); } int gc_object_is_old_generation_slow(struct gc_mutator *mut, struct gc_ref obj) { return 0; } void gc_write_barrier_slow(struct gc_mutator *mut, struct gc_ref obj, size_t obj_size, struct gc_edge edge, struct gc_ref new_val) { } int* gc_safepoint_flag_loc(struct gc_mutator *mut) { GC_CRASH(); } void gc_safepoint_slow(struct gc_mutator *mut) { GC_CRASH(); } static int collect_for_large_alloc(struct gc_mutator *mut, size_t npages) { size_t bytes = npages * mutator_semi_space(mut)->page_size; // Large object pages don't need a copy reserve. bytes /= 2; return collect_for_alloc(mut, bytes); } static void* allocate_large(struct gc_mutator *mut, size_t size) { struct gc_heap *heap = mutator_heap(mut); struct large_object_space *space = heap_large_object_space(heap); struct semi_space *semi_space = heap_semi_space(heap); size_t npages = large_object_space_npages(space, size); if (!semi_space_steal_pages(semi_space, npages) && !collect_for_large_alloc(mut, npages)) return heap->allocation_failure(heap, size); void *ret = large_object_space_alloc(space, npages, GC_TRACE_PRECISELY); if (!ret) { perror("weird: we have the space but mmap didn't work"); GC_CRASH(); } return ret; } void* gc_allocate_slow(struct gc_mutator *mut, size_t size, enum gc_allocation_kind kind) { if (GC_UNLIKELY(kind != GC_ALLOCATION_TAGGED && kind != GC_ALLOCATION_TAGGED_POINTERLESS)) { fprintf(stderr, "semispace collector cannot make allocations of kind %d\n", (int)kind); GC_CRASH(); } if (size > gc_allocator_large_threshold()) return allocate_large(mut, size); struct semi_space *space = mutator_semi_space(mut); while (1) { uintptr_t addr = space->hp; uintptr_t new_hp = align_up (addr + size, GC_ALIGNMENT); if (space->limit < new_hp) { if (collect_for_alloc(mut, size)) continue; struct gc_heap *heap = mutator_heap(mut); return heap->allocation_failure(heap, size); } space->hp = new_hp; return (void *)addr; } } void gc_pin_object(struct gc_mutator *mut, struct gc_ref ref) { GC_CRASH(); } struct gc_ephemeron* gc_allocate_ephemeron(struct gc_mutator *mut) { return gc_allocate(mut, gc_ephemeron_size(), GC_ALLOCATION_TAGGED); } void gc_ephemeron_init(struct gc_mutator *mut, struct gc_ephemeron *ephemeron, struct gc_ref key, struct gc_ref value) { gc_ephemeron_init_internal(mutator_heap(mut), ephemeron, key, value); } struct gc_ref gc_ephemeron_swap_value(struct gc_mutator *mut, struct gc_ephemeron *e, struct gc_ref ref) { return gc_ephemeron_swap_value_internal(e, ref); } struct gc_finalizer* gc_allocate_finalizer(struct gc_mutator *mut) { return gc_allocate(mut, gc_finalizer_size(), GC_ALLOCATION_TAGGED); } void gc_finalizer_attach(struct gc_mutator *mut, struct gc_finalizer *finalizer, unsigned priority, struct gc_ref object, struct gc_ref closure) { gc_finalizer_init_internal(finalizer, object, closure); gc_finalizer_attach_internal(mutator_heap(mut)->finalizer_state, finalizer, priority); // No write barrier. } struct gc_finalizer* gc_pop_finalizable(struct gc_mutator *mut) { return gc_finalizer_state_pop(mutator_heap(mut)->finalizer_state); } void gc_set_finalizer_callback(struct gc_heap *heap, gc_finalizer_callback callback) { gc_finalizer_state_set_callback(heap->finalizer_state, callback); } static int region_init(struct region *region, size_t size) { region->base = 0; region->active_size = 0; region->mapped_size = 0; if (!grow_region_if_needed(region, size)) { fprintf(stderr, "failed to allocated %zu bytes\n", size); return 0; } region->active_size = size; return 1; } static int semi_space_init(struct semi_space *space, struct gc_heap *heap) { // Allocate even numbers of pages. size_t page_size = gc_platform_page_size(); size_t size = align_up(heap->size, page_size * 2); space->page_size = page_size; space->stolen_pages = 0; if (!region_init(&space->from_space, size / 2)) return 0; if (!region_init(&space->to_space, size / 2)) return 0; space->hp = space->to_space.base; space->limit = space->hp + space->to_space.active_size; return 1; } static int heap_prepare_pending_ephemerons(struct gc_heap *heap) { struct gc_pending_ephemerons *cur = heap->pending_ephemerons; size_t target = heap->size * heap->pending_ephemerons_size_factor; double slop = heap->pending_ephemerons_size_slop; heap->pending_ephemerons = gc_prepare_pending_ephemerons(cur, target, slop); return !!heap->pending_ephemerons; } unsigned gc_heap_ephemeron_trace_epoch(struct gc_heap *heap) { return heap->count; } static uint64_t get_allocation_counter(struct gc_heap *heap) { return heap->total_allocated_bytes_at_last_gc; } uint64_t gc_allocation_counter(struct gc_heap *heap) { return get_allocation_counter(heap); } static void ignore_async_heap_size_adjustment(struct gc_heap *heap, size_t size) { } static void* allocation_failure(struct gc_heap *heap, size_t size) { fprintf(stderr, "ran out of space, heap size %zu\n", heap->size); GC_CRASH(); return NULL; } void gc_heap_set_allocation_failure_handler(struct gc_heap *heap, void* (*handler)(struct gc_heap*, size_t)) { heap->allocation_failure = handler; } static int heap_init(struct gc_heap *heap, const struct gc_options *options) { heap->extern_space = NULL; heap->pending_ephemerons_size_factor = 0.01; heap->pending_ephemerons_size_slop = 0.5; heap->count = 0; heap->options = options; heap->size = options->common.heap_size; heap->roots = NULL; heap->finalizer_state = gc_make_finalizer_state(); if (!heap->finalizer_state) GC_CRASH(); heap->sizer = gc_make_heap_sizer(heap, &options->common, get_allocation_counter, ignore_async_heap_size_adjustment, NULL); heap->allocation_failure = allocation_failure; return heap_prepare_pending_ephemerons(heap); } int gc_option_from_string(const char *str) { return gc_common_option_from_string(str); } struct gc_options* gc_allocate_options(void) { struct gc_options *ret = malloc(sizeof(struct gc_options)); gc_init_common_options(&ret->common); return ret; } int gc_options_set_int(struct gc_options *options, int option, int value) { return gc_common_options_set_int(&options->common, option, value); } int gc_options_set_size(struct gc_options *options, int option, size_t value) { return gc_common_options_set_size(&options->common, option, value); } int gc_options_set_double(struct gc_options *options, int option, double value) { return gc_common_options_set_double(&options->common, option, value); } int gc_options_parse_and_set(struct gc_options *options, int option, const char *value) { return gc_common_options_parse_and_set(&options->common, option, value); } int gc_init(const struct gc_options *options, struct gc_stack_addr stack_base, struct gc_heap **heap, struct gc_mutator **mut, struct gc_event_listener event_listener, void *event_listener_data) { GC_ASSERT_EQ(gc_allocator_allocation_pointer_offset(), offsetof(struct semi_space, hp)); GC_ASSERT_EQ(gc_allocator_allocation_limit_offset(), offsetof(struct semi_space, limit)); if (!options) options = gc_allocate_options(); if (options->common.parallelism != 1) fprintf(stderr, "warning: parallelism unimplemented in semispace copying collector\n"); *mut = calloc(1, sizeof(struct gc_mutator)); if (!*mut) GC_CRASH(); *heap = mutator_heap(*mut); if (!heap_init(*heap, options)) return 0; (*heap)->event_listener = event_listener; (*heap)->event_listener_data = event_listener_data; HEAP_EVENT(*heap, init, (*heap)->size); if (!semi_space_init(heap_semi_space(*heap), *heap)) return 0; struct gc_background_thread *thread = NULL; if (!large_object_space_init(heap_large_object_space(*heap), *heap, thread)) return 0; // Ignore stack base, as we are precise. (*mut)->roots = NULL; (*mut)->event_listener_data = event_listener.mutator_added(event_listener_data); return 1; } void gc_mutator_set_roots(struct gc_mutator *mut, struct gc_mutator_roots *roots) { mut->roots = roots; } void gc_heap_set_roots(struct gc_heap *heap, struct gc_heap_roots *roots) { heap->roots = roots; } void gc_heap_set_extern_space(struct gc_heap *heap, struct gc_extern_space *space) { heap->extern_space = space; } struct gc_mutator* gc_init_for_thread(struct gc_stack_addr base, struct gc_heap *heap) { fprintf(stderr, "Semispace copying collector not appropriate for multithreaded use.\n"); GC_CRASH(); } void gc_finish_for_thread(struct gc_mutator *space) { } void* gc_call_without_gc(struct gc_mutator *mut, void* (*f)(void*), void *data) { // Can't be threads, then there won't be collection. return f(data); }