void S_alloc_init() { ISPC s; IGEN g; UINT i; if (S_boot_time) { /* reset the allocation tables */ for (s = 0; s <= max_real_space; s++) { for (g = 0; g <= static_generation; g++) { S_G.base_loc[s][g] = FIX(0); S_G.first_loc[s][g] = FIX(0); S_G.next_loc[s][g] = FIX(0); S_G.bytes_left[s][g] = 0; S_G.bytes_of_space[s][g] = 0; } } /* initialize the dirty-segment lists. */ for (i = 0; i < DIRTY_SEGMENT_LISTS; i += 1) { S_G.dirty_segments[i] = NULL; } S_G.collect_trip_bytes = default_collect_trip_bytes; /* set to final value in prim.c when known */ S_protect(&S_G.nonprocedure_code); S_G.nonprocedure_code = FIX(0); S_protect(&S_G.null_vector); find_room(space_new, 0, type_typed_object, size_vector(0), S_G.null_vector); VECTTYPE(S_G.null_vector) = (0 << vector_length_offset) | type_vector; S_protect(&S_G.null_fxvector); find_room(space_new, 0, type_typed_object, size_fxvector(0), S_G.null_fxvector); FXVECTOR_TYPE(S_G.null_fxvector) = (0 << fxvector_length_offset) | type_fxvector; S_protect(&S_G.null_bytevector); find_room(space_new, 0, type_typed_object, size_bytevector(0), S_G.null_bytevector); BYTEVECTOR_TYPE(S_G.null_bytevector) = (0 << bytevector_length_offset) | type_bytevector; S_protect(&S_G.null_string); find_room(space_new, 0, type_typed_object, size_string(0), S_G.null_string); STRTYPE(S_G.null_string) = (0 << string_length_offset) | type_string; } }
void S_thread_init() { if (S_boot_time) { S_protect(&S_G.threadno); S_G.threadno = FIX(0); #ifdef PTHREADS /* this is also reset in main.c after heap restoration */ s_thread_mutex_init(&S_tc_mutex.pmutex); S_tc_mutex.owner = s_thread_self(); S_tc_mutex.count = 0; s_thread_cond_init(&S_collect_cond); S_tc_mutex_depth = 0; #endif /* PTHREADS */ } }
static void main_init() { ptr tc = get_thread_context(); ptr p; INT i; /* force thread inline allocation to go through find_room until ready */ AP(tc) = (ptr)0; EAP(tc) = (ptr)0; REAL_EAP(tc) = (ptr)0; /* set up dummy CP so locking in read/write/Scall won't choke */ CP(tc) = Svoid; CODERANGESTOFLUSH(tc) = Snil; if (S_boot_time) S_G.protect_next = 0; S_segment_init(); S_alloc_init(); S_thread_init(); S_intern_init(); S_gc_init(); S_number_init(); S_schsig_init(); S_new_io_init(); S_print_init(); S_stats_init(); S_foreign_init(); S_prim_init(); S_prim5_init(); S_fasl_init(); S_machine_init(); S_flushcache_init(); /* must come after S_machine_init(); */ #ifdef FEATURE_EXPEDITOR S_expeditor_init(); #endif /* FEATURE_EXPEDITOR */ if (!S_boot_time) return; FXLENGTHBV(tc) = p = S_bytevector(256); for (i = 0; i < 256; i += 1) { BVIT(p, i) = (iptr)FIX(i & 0x80 ? 8 : i & 0x40 ? 7 : i & 0x20 ? 6 : i & 0x10 ? 5 : i & 0x08 ? 4 : i & 0x04 ? 3 : i & 0x02 ? 2 : i & 0x01 ? 1 : 0); } FXFIRSTBITSETBV(tc) = p = S_bytevector(256); for (i = 0; i < 256; i += 1) { BVIT(p, i) = (iptr)FIX(i & 0x01 ? 0 : i & 0x02 ? 1 : i & 0x04 ? 2 : i & 0x08 ? 3 : i & 0x10 ? 4 : i & 0x20 ? 5 : i & 0x40 ? 6 : i & 0x80 ? 7 : 0); } NULLIMMUTABLEVECTOR(tc) = S_null_immutable_vector(); NULLIMMUTABLEFXVECTOR(tc) = S_null_immutable_fxvector(); NULLIMMUTABLEBYTEVECTOR(tc) = S_null_immutable_bytevector(); NULLIMMUTABLESTRING(tc) = S_null_immutable_string(); PARAMETERS(tc) = S_G.null_vector; for (i = 0 ; i < virtual_register_count ; i += 1) { VIRTREG(tc, i) = FIX(0); } p = S_code(tc, type_code, size_rp_header); CODERELOC(p) = S_relocation_table(0); CODENAME(p) = Sfalse; CODEARITYMASK(p) = FIX(0); CODEFREE(p) = 0; CODEINFO(p) = Sfalse; CODEPINFOS(p) = Snil; RPHEADERFRAMESIZE(&CODEIT(p, 0)) = 0; RPHEADERLIVEMASK(&CODEIT(p, 0)) = 0; RPHEADERTOPLINK(&CODEIT(p, 0)) = (uptr)&RPHEADERTOPLINK(&CODEIT(p, 0)) - (uptr)p; S_protect(&S_G.dummy_code_object); S_G.dummy_code_object = p; S_protect(&S_G.error_invoke_code_object); S_G.error_invoke_code_object = Snil; S_protect(&S_G.invoke_code_object); S_G.invoke_code_object = Snil; S_protect(&S_G.active_threads_id); S_G.active_threads_id = S_intern((const unsigned char *)"$active-threads"); S_set_symbol_value(S_G.active_threads_id, FIX(0)); S_protect(&S_G.heap_reserve_ratio_id); S_G.heap_reserve_ratio_id = S_intern((const unsigned char *)"$heap-reserve-ratio"); SETSYMVAL(S_G.heap_reserve_ratio_id, Sflonum(default_heap_reserve_ratio)); S_protect(&S_G.scheme_version_id); S_G.scheme_version_id = S_intern((const unsigned char *)"$scheme-version"); S_protect(&S_G.make_load_binary_id); S_G.make_load_binary_id = S_intern((const unsigned char *)"$make-load-binary"); S_protect(&S_G.load_binary); S_G.load_binary = Sfalse; }
void S_gc_init() { IGEN g; INT i; S_checkheap = 0; /* 0 for disabled, 1 for enabled */ S_checkheap_errors = 0; /* count of errors detected by checkheap */ checkheap_noisy = 0; /* 0 for error output only; 1 for more noisy output */ if (S_checkheap) { printf(checkheap_noisy ? "NB: check_heap is enabled and noisy\n" : "NB: check_heap_is_enabled\n"); fflush(stdout); } #ifndef WIN32 for (g = 0; g <= static_generation; g++) { S_child_processes[g] = Snil; } #endif /* WIN32 */ if (!S_boot_time) return; for (g = 0; g <= static_generation; g++) { S_G.guardians[g] = Snil; S_G.locked_objects[g] = Snil; S_G.unlocked_objects[g] = Snil; } S_G.max_nonstatic_generation = S_G.new_max_nonstatic_generation = S_G.min_free_gen = S_G.new_min_free_gen = default_max_nonstatic_generation; for (g = 0; g <= static_generation; g += 1) { for (i = 0; i < countof_types; i += 1) { S_G.countof[g][i] = 0; S_G.bytesof[g][i] = 0; } S_G.gctimestamp[g] = 0; S_G.rtds_with_counts[g] = Snil; } S_G.countof[static_generation][countof_oblist] += 1; S_G.bytesof[static_generation][countof_oblist] += S_G.oblist_length * sizeof(bucket *); S_protect(&S_G.static_id); S_G.static_id = S_intern((const unsigned char *)"static"); S_protect(&S_G.countof_names); S_G.countof_names = S_vector(countof_types); for (i = 0; i < countof_types; i += 1) { INITVECTIT(S_G.countof_names, i) = FIX(0); S_G.countof_size[i] = 0; } INITVECTIT(S_G.countof_names, countof_pair) = S_intern((const unsigned char *)"pair"); S_G.countof_size[countof_pair] = size_pair; INITVECTIT(S_G.countof_names, countof_symbol) = S_intern((const unsigned char *)"symbol"); S_G.countof_size[countof_symbol] = size_symbol; INITVECTIT(S_G.countof_names, countof_flonum) = S_intern((const unsigned char *)"flonum"); S_G.countof_size[countof_flonum] = size_flonum; INITVECTIT(S_G.countof_names, countof_closure) = S_intern((const unsigned char *)"procedure"); S_G.countof_size[countof_closure] = 0; INITVECTIT(S_G.countof_names, countof_continuation) = S_intern((const unsigned char *)"continuation"); S_G.countof_size[countof_continuation] = size_continuation; INITVECTIT(S_G.countof_names, countof_bignum) = S_intern((const unsigned char *)"bignum"); S_G.countof_size[countof_bignum] = 0; INITVECTIT(S_G.countof_names, countof_ratnum) = S_intern((const unsigned char *)"ratnum"); S_G.countof_size[countof_ratnum] = size_ratnum; INITVECTIT(S_G.countof_names, countof_inexactnum) = S_intern((const unsigned char *)"inexactnum"); S_G.countof_size[countof_inexactnum] = size_inexactnum; INITVECTIT(S_G.countof_names, countof_exactnum) = S_intern((const unsigned char *)"exactnum"); S_G.countof_size[countof_exactnum] = size_exactnum; INITVECTIT(S_G.countof_names, countof_box) = S_intern((const unsigned char *)"box"); S_G.countof_size[countof_box] = size_box; INITVECTIT(S_G.countof_names, countof_port) = S_intern((const unsigned char *)"port"); S_G.countof_size[countof_port] = size_port; INITVECTIT(S_G.countof_names, countof_code) = S_intern((const unsigned char *)"code"); S_G.countof_size[countof_code] = 0; INITVECTIT(S_G.countof_names, countof_thread) = S_intern((const unsigned char *)"thread"); S_G.countof_size[countof_thread] = size_thread; INITVECTIT(S_G.countof_names, countof_tlc) = S_intern((const unsigned char *)"tlc"); S_G.countof_size[countof_tlc] = size_tlc; INITVECTIT(S_G.countof_names, countof_rtd_counts) = S_intern((const unsigned char *)"rtd-counts"); S_G.countof_size[countof_rtd_counts] = size_rtd_counts; INITVECTIT(S_G.countof_names, countof_stack) = S_intern((const unsigned char *)"stack"); S_G.countof_size[countof_stack] = 0; INITVECTIT(S_G.countof_names, countof_relocation_table) = S_intern((const unsigned char *)"reloc-table"); S_G.countof_size[countof_relocation_table] = 0; INITVECTIT(S_G.countof_names, countof_weakpair) = S_intern((const unsigned char *)"weakpair"); S_G.countof_size[countof_weakpair] = size_pair; INITVECTIT(S_G.countof_names, countof_vector) = S_intern((const unsigned char *)"vector"); S_G.countof_size[countof_vector] = 0; INITVECTIT(S_G.countof_names, countof_string) = S_intern((const unsigned char *)"string"); S_G.countof_size[countof_string] = 0; INITVECTIT(S_G.countof_names, countof_fxvector) = S_intern((const unsigned char *)"fxvector"); S_G.countof_size[countof_fxvector] = 0; INITVECTIT(S_G.countof_names, countof_bytevector) = S_intern((const unsigned char *)"bytevector"); S_G.countof_size[countof_bytevector] = 0; INITVECTIT(S_G.countof_names, countof_locked) = S_intern((const unsigned char *)"locked"); S_G.countof_size[countof_locked] = 0; INITVECTIT(S_G.countof_names, countof_guardian) = S_intern((const unsigned char *)"guardian"); S_G.countof_size[countof_guardian] = size_guardian_entry; INITVECTIT(S_G.countof_names, countof_oblist) = S_intern((const unsigned char *)"oblist"); S_G.countof_size[countof_guardian] = 0; INITVECTIT(S_G.countof_names, countof_ephemeron) = S_intern((const unsigned char *)"ephemron"); S_G.countof_size[countof_ephemeron] = 0; for (i = 0; i < countof_types; i += 1) { if (Svector_ref(S_G.countof_names, i) == FIX(0)) { fprintf(stderr, "uninitialized countof_name at index %d\n", i); S_abnormal_exit(); } } }