diff --git a/collects/tests/racket/place-channel.rkt b/collects/tests/racket/place-channel.rkt index 7b97673c83..f8d1a7ce43 100644 --- a/collects/tests/racket/place-channel.rkt +++ b/collects/tests/racket/place-channel.rkt @@ -166,6 +166,60 @@ (place-wait p)))) (define (main) + (let () + (define p1 (place ch + (define in (place-channel-get ch)) + (displayln (place-channel-get in)))) + (define p2 (place ch + (define in (place-channel-get ch)) + (sleep 1) + (define t (thread + (lambda () + (displayln (place-channel-get in))))) + (sleep 1) + (printf "bye\n") + 'done)) + (define-values (in out) (place-channel)) + (place-channel-put p1 in) + (place-channel-put p2 in) + (sleep 4) + (place-channel-put out 'val) + (sleep 4)) + + ; test signal-handle vector growing + (let () + (define ps (for/list ([i (in-range 4)]) + (place ch (define in (place-channel-get ch)) (displayln (place-channel-get in))))) + (define-values (in out) (place-channel)) + (for ([p ps]) (place-channel-put p in)) + (sleep 4) + (for ([x (list 'val1 'val2 'val3 'val4)]) (place-channel-put out x)) + (sleep 4) + (for ([p ps]) (place-wait p))) + + ; test signal-handle vector shrinking + (let () + (define ps (for/list ([i (in-range 4)]) + (place ch (define in (place-channel-get ch)) (displayln (place-channel-get in))))) + (define-values (in out) (place-channel)) + (for ([p ps]) (place-channel-put p in)) + (sleep 4) + (for ([x (list 'val1 'val2 'val3 'val4)]) (place-channel-put out x)) + (sleep 4) + (for ([p ps]) (place-wait p)) + + (define p0 (place ch + (define in (place-channel-get ch)) + (for ([i (in-range 4)]) + (printf "p0 got ~a\n" (place-channel-get in))))) + (place-channel-put p0 in) + (for ([x (list 'p0val1 'p0val2 'p0val3)]) (place-channel-put out x)) + (sleep 4) + (place-channel-put out 'p0val4) + (for ([p ps]) (place-wait p0))) + + + (let ([pl (place-worker)]) (define flv1 (shared-flvector 0.0 1.0 2.0 3.0)) (define flv2 (make-shared-flvector 4 3.0)) diff --git a/src/racket/src/env.c b/src/racket/src/env.c index c5697b267d..2787e824d6 100644 --- a/src/racket/src/env.c +++ b/src/racket/src/env.c @@ -281,13 +281,16 @@ Scheme_Env *scheme_engine_instance_init() { scheme_spawn_master_place(); #endif + env = place_instance_init(stack_base, 1); #if defined(MZ_PRECISE_GC) && defined(MZ_USE_PLACES) { - void *signal_fd; - signal_fd = scheme_get_signal_handle(); - GC_set_put_external_event_fd(signal_fd); + void *signal_handle; + place_object = (Scheme_Place_Object*) scheme_make_place_object(); + signal_handle = scheme_get_signal_handle(); + GC_set_put_external_event_fd(signal_handle); + place_object->signal_handle = signal_handle; } #endif diff --git a/src/racket/src/mzmark_place.inc b/src/racket/src/mzmark_place.inc index 259ec371c0..3c08bb5d39 100644 --- a/src/racket/src/mzmark_place.inc +++ b/src/racket/src/mzmark_place.inc @@ -27,6 +27,27 @@ static int place_bi_channel_val_FIXUP(void *p, struct NewGC *gc) { #define place_bi_channel_val_IS_CONST_SIZE 1 +static int place_object_val_SIZE(void *p, struct NewGC *gc) { + return + gcBYTES_TO_WORDS(sizeof(Scheme_Place_Object)); +} + +static int place_object_val_MARK(void *p, struct NewGC *gc) { + + return + gcBYTES_TO_WORDS(sizeof(Scheme_Place_Object)); +} + +static int place_object_val_FIXUP(void *p, struct NewGC *gc) { + + return + gcBYTES_TO_WORDS(sizeof(Scheme_Place_Object)); +} + +#define place_object_val_IS_ATOMIC 0 +#define place_object_val_IS_CONST_SIZE 1 + + static int place_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Place)); diff --git a/src/racket/src/mzmarksrc.c b/src/racket/src/mzmarksrc.c index c79c94505c..2b31c5cf4a 100644 --- a/src/racket/src/mzmarksrc.c +++ b/src/racket/src/mzmarksrc.c @@ -1441,6 +1441,13 @@ place_bi_channel_val { gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel)); } +place_object_val { + mark: + + size: + gcBYTES_TO_WORDS(sizeof(Scheme_Place_Object)); +} + place_val { mark: Scheme_Place *pr = (Scheme_Place *)p; diff --git a/src/racket/src/place.c b/src/racket/src/place.c index 0885fa48b7..b95237d9e7 100644 --- a/src/racket/src/place.c +++ b/src/racket/src/place.c @@ -45,6 +45,7 @@ static Scheme_Object *place_async_receive(Scheme_Place_Async_Channel *ch); static Scheme_Object *places_deep_copy_to_master(Scheme_Object *so); static Scheme_Object *make_place_dead(int argc, Scheme_Object *argv[]); static int place_dead_ready(Scheme_Object *o, Scheme_Schedule_Info *sinfo); +static void* GC_master_malloc_tagged(size_t size); #if defined(MZ_USE_PLACES) && defined(MZ_PRECISE_GC) static Scheme_Object *places_deep_copy_worker(Scheme_Object *so, Scheme_Hash_Table **ht, @@ -164,19 +165,16 @@ Scheme_Object *place_sleep(int argc, Scheme_Object *args[]) { return scheme_void; } -/* this struct is NOT a Scheme_Object - * it is shared acrosss place boundaries and - * must be allocated with malloc and free*/ -typedef struct Scheme_Place_Object { - mzrt_mutex *lock; - char die; - char pbreak; - char ref; - void *signal_handle; - void *parent_signal_handle; /* set to NULL when the place terminates */ - intptr_t result; /* initialized to 1, reset when parent_signal_handle becomes NULL */ - /*Thread_Local_Variables *tlvs; */ -} Scheme_Place_Object; +Scheme_Object *scheme_make_place_object() { + Scheme_Place_Object *place_obj; + place_obj = GC_master_malloc_tagged(sizeof(Scheme_Place_Object)); + place_obj->so.type = scheme_place_object_type; + mzrt_mutex_create(&place_obj->lock); + place_obj->die = 0; + place_obj->pbreak = 0; + place_obj->result = 1; + return (Scheme_Object *)place_obj; +} Scheme_Object *scheme_place(int argc, Scheme_Object *args[]) { Scheme_Place *place; @@ -189,13 +187,8 @@ Scheme_Object *scheme_place(int argc, Scheme_Object *args[]) { /* create place object */ place = MALLOC_ONE_TAGGED(Scheme_Place); place->so.type = scheme_place_type; - place_obj = malloc(sizeof(Scheme_Place_Object)); - mzrt_mutex_create(&place_obj->lock); + place_obj = (Scheme_Place_Object *) scheme_make_place_object(); place->place_obj = place_obj; - place_obj->die = 0; - place_obj->pbreak = 0; - place_obj->ref= 1; - place_obj->result = 1; { GC_CAN_IGNORE void *handle; handle = scheme_get_signal_handle(); @@ -276,7 +269,6 @@ Scheme_Object *scheme_place(int argc, Scheme_Object *args[]) { static void do_place_kill(Scheme_Place *place) { Scheme_Place_Object *place_obj; - int ref = 0; place_obj = place->place_obj; if (!place_obj) return; @@ -284,19 +276,15 @@ static void do_place_kill(Scheme_Place *place) { mzrt_mutex_lock(place_obj->lock); - ref = --place_obj->ref; place_obj->die = 1; - if (ref != 0) { scheme_signal_received_at(place_obj->signal_handle); } + if (place_obj->signal_handle) { scheme_signal_received_at(place_obj->signal_handle); } place->result = place_obj->result; mzrt_mutex_unlock(place_obj->lock); } - if (ref == 0) - free(place->place_obj); - scheme_remove_managed(place->mref, (Scheme_Object *)place); place->place_obj = NULL; } @@ -345,7 +333,7 @@ static Scheme_Object *place_break(int argc, Scheme_Object *args[]) { static int place_deadp(Scheme_Object *place) { Scheme_Place_Object *place_obj; - int ref = 0; + int dead = 0; place_obj = (Scheme_Place_Object*) ((Scheme_Place *)place)->place_obj; if (place_obj == NULL) { @@ -355,12 +343,12 @@ static int place_deadp(Scheme_Object *place) { { mzrt_mutex_lock(place_obj->lock); - ref = place_obj->ref; + dead = place_obj->die; mzrt_mutex_unlock(place_obj->lock); } - if (ref > 1) { return 0; } - return 1; + if (dead) { return 1; } + return 9; } static Scheme_Object *make_place_dead(int argc, Scheme_Object *argv[]) @@ -1563,20 +1551,6 @@ void scheme_place_check_for_interruption() scheme_break_thread(NULL); } -static void place_release_place_object() { - int ref = 0; - Scheme_Place_Object *place_obj = place_object; - if (place_obj) { - mzrt_mutex_lock(place_obj->lock); - ref = --place_obj->ref; - place_obj->die = 1; - mzrt_mutex_unlock(place_obj->lock); - - if (ref == 0) { free(place_object); } - place_object = NULL; - } -} - static void place_set_result(Scheme_Object *result) { intptr_t status; @@ -1604,7 +1578,6 @@ static Scheme_Object *def_place_exit_handler_proc(int argc, Scheme_Object *argv[ /*printf("Leavin place: proc thread id%u\n", ptid);*/ scheme_place_instance_destroy(0); - place_release_place_object(); mz_proc_thread_exit(NULL); return scheme_void; /* Never get here */ @@ -1648,7 +1621,6 @@ static void *place_start_proc_after_stack(void *data_arg, void *stack_base) { } place_obj = place_data->place_obj; place_object = place_obj; - place_obj->ref++; { void *signal_handle; @@ -1665,7 +1637,7 @@ static void *place_start_proc_after_stack(void *data_arg, void *stack_base) { # endif - /* at point point, don't refer to place_data or its content + /* at point, don't refer to place_data or its content anymore, because it's allocated in the other place */ scheme_set_root_param(MZCONFIG_EXIT_HANDLER, scheme_def_place_exit_proc); @@ -1702,11 +1674,11 @@ static void *place_start_proc_after_stack(void *data_arg, void *stack_base) { scheme_log(NULL, SCHEME_LOG_DEBUG, 0, "place %d: exiting", scheme_current_place_id); + place_obj->signal_handle = NULL; + /*printf("Leavin place: proc thread id%u\n", ptid);*/ scheme_place_instance_destroy(place_obj->die); - place_release_place_object(); - return NULL; } @@ -2107,6 +2079,19 @@ static Scheme_Object *place_channel_p(int argc, Scheme_Object *args[]) return SAME_TYPE(SCHEME_TYPE(args[0]), scheme_place_bi_channel_type) ? scheme_true : scheme_false; } +static Scheme_Object *GC_master_make_vector(int size) { + Scheme_Object *v; +#ifdef MZ_PRECISE_GC + void *original_gc; + original_gc = GC_switch_to_master_gc(); +#endif + v = scheme_make_vector(size, NULL); +#ifdef MZ_PRECISE_GC + GC_switch_back_from_master(original_gc); +#endif + return v; +} + static void place_async_send(Scheme_Place_Async_Channel *ch, Scheme_Object *uo) { void *msg_memory = NULL; Scheme_Object *o; @@ -2150,11 +2135,113 @@ static void place_async_send(Scheme_Place_Async_Channel *ch, Scheme_Object *uo) ++ch->count; ch->in = (++ch->in % ch->size); } - mzrt_mutex_unlock(ch->lock); if (!cnt && ch->wakeup_signal) { - /*wake up possibly sleeping receiver */ - scheme_signal_received_at(ch->wakeup_signal); + /*wake up possibly sleeping single receiver */ + if (SCHEME_PLACE_OBJECTP(ch->wakeup_signal)) + scheme_signal_received_at(((Scheme_Place_Object *) ch->wakeup_signal)->signal_handle); + /*wake up possibly sleeping multiple receiver */ + else if (SCHEME_VECTORP(ch->wakeup_signal)) { + Scheme_Object *v = ch->wakeup_signal; + int i; + int size = SCHEME_VEC_SIZE(v); + int alive = 0; + for (i = 0; i < size; i++) { + Scheme_Place_Object *o3; + o3 = (Scheme_Place_Object *)SCHEME_VEC_ELS(v)[i]; + if (o3 && o3->signal_handle != NULL) { + scheme_signal_received_at(o3->signal_handle); + alive++; + } + else + SCHEME_VEC_ELS(v)[i] = NULL; + } + /* shrink if more than half are unused */ + if (alive < (size / 2)) { + if (alive == 1) { + ch->wakeup_signal = NULL; + for (i = 0; i < size; i++) { + Scheme_Place_Object *o2 = (Scheme_Place_Object *)SCHEME_VEC_ELS(v)[i]; + if (o2 && o2->signal_handle != NULL) { + ch->wakeup_signal = (Scheme_Object *)o2; + break; + } + } + } + else { + Scheme_Object *nv; + int ncnt = 0; + nv = GC_master_make_vector(size/2); + for (i = 0; i < size; i++) { + Scheme_Place_Object *o2 = (Scheme_Place_Object *)SCHEME_VEC_ELS(v)[i]; + if (o2 && o2->signal_handle != NULL) { + SCHEME_VEC_ELS(nv)[ncnt] = (Scheme_Object *)o2; + ncnt++; + } + } + ch->wakeup_signal = nv; + } + } + } + else { + printf("Opps not a valid ch->wakeup_signal\n"); + exit(1); + } + } + mzrt_mutex_unlock(ch->lock); +} + +static void register_place_object_with_channel(Scheme_Place_Async_Channel *ch, Scheme_Object *o) { + if (ch->wakeup_signal == o) { + return; + } + else if (!ch->wakeup_signal) + ch->wakeup_signal = o; + else if (SCHEME_PLACE_OBJECTP(ch->wakeup_signal) + && ( (Scheme_Place_Object *) ch->wakeup_signal)->signal_handle == NULL) + ch->wakeup_signal = o; + else if (SCHEME_VECTORP(ch->wakeup_signal)) { + int i = 0; + Scheme_Object *v = ch->wakeup_signal; + int size = SCHEME_VEC_SIZE(v); + /* look for unused slot in wakeup vector */ + for (i = 0; i < size; i++) { + Scheme_Object *vo = SCHEME_VEC_ELS(v)[i]; + if (vo == o) { + return; + } + else if (!vo) { + SCHEME_VEC_ELS(v)[i] = o; + return; + } + else if (SCHEME_PLACE_OBJECTP(vo) && + ((Scheme_Place_Object *)vo)->signal_handle == NULL) { + SCHEME_VEC_ELS(v)[i] = o; + return; + } + } + /* fall through to here, need to grow wakeup vector */ + { + Scheme_Object *nv; + nv = GC_master_make_vector(size*2); + for (i = 0; i < size; i++) { + SCHEME_VEC_ELS(nv)[i] = SCHEME_VEC_ELS(v)[i]; + } + SCHEME_VEC_ELS(nv)[size+1] = o; + ch->wakeup_signal = nv; + } + } + /* grow from single wakeup to multiple wakeups */ + else if (SCHEME_PLACE_OBJECTP(ch->wakeup_signal)) { + Scheme_Object *v; + v = GC_master_make_vector(2); + SCHEME_VEC_ELS(v)[0] = ch->wakeup_signal; + SCHEME_VEC_ELS(v)[1] = o; + ch->wakeup_signal = v; + } + else { + printf("Opps not a valid ch->wakeup_signal\n"); + exit(1); } } @@ -2164,9 +2251,7 @@ static Scheme_Object *scheme_place_async_try_receive(Scheme_Place_Async_Channel mzrt_mutex_lock(ch->lock); { - void *signaldescr; - signaldescr = scheme_get_signal_handle(); - ch->wakeup_signal = signaldescr; + register_place_object_with_channel(ch, (Scheme_Object *) place_object); if (ch->count > 0) { /* GET MSG */ msg = ch->msgs[ch->out]; msg_memory = ch->msg_memory[ch->out]; @@ -2190,9 +2275,7 @@ static int scheme_place_async_ch_ready(Scheme_Place_Async_Channel *ch) { int ready = 0; mzrt_mutex_lock(ch->lock); { - void *signaldescr; - signaldescr = scheme_get_signal_handle(); - ch->wakeup_signal = signaldescr; + register_place_object_with_channel(ch, (Scheme_Object *) place_object); if (ch->count > 0) ready = 1; } mzrt_mutex_unlock(ch->lock); @@ -2223,9 +2306,11 @@ static Scheme_Object *place_async_receive(Scheme_Place_Async_Channel *ch) { msg = scheme_place_async_try_receive(ch); if(msg) break; else { - void *signaldescr; - signaldescr = scheme_get_signal_handle(); - ch->wakeup_signal = signaldescr; + /* + mzrt_mutex_lock(ch->lock); + register_place_object_with_channel(ch, (Scheme_Object *) place_object); + mzrt_mutex_unlock(ch->lock); + */ scheme_thread_block(0); scheme_block_until((Scheme_Ready_Fun) scheme_place_async_ch_ready, NULL, (Scheme_Object *) ch, 0); @@ -2247,6 +2332,7 @@ START_XFORM_SKIP; static void register_traversers(void) { GC_REG_TRAV(scheme_place_type, place_val); + GC_REG_TRAV(scheme_place_object_type, place_object_val); GC_REG_TRAV(scheme_place_async_channel_type, place_async_channel_val); GC_REG_TRAV(scheme_place_bi_channel_type, place_bi_channel_val); } diff --git a/src/racket/src/schpriv.h b/src/racket/src/schpriv.h index 7fc582ad94..2563a87924 100644 --- a/src/racket/src/schpriv.h +++ b/src/racket/src/schpriv.h @@ -3618,7 +3618,21 @@ typedef struct Scheme_Place { intptr_t result; /* set when place_obj becomes NULL */ } Scheme_Place; +typedef struct Scheme_Place_Object { + Scheme_Object so; + mzrt_mutex *lock; + char die; + char pbreak; + void *signal_handle; + void *parent_signal_handle; /* set to NULL when the place terminates */ + intptr_t result; /* initialized to 1, reset when parent_signal_handle becomes NULL */ + /*Thread_Local_Variables *tlvs; */ +} Scheme_Place_Object; + +#define SCHEME_PLACE_OBJECTP(o) (SCHEME_TYPE(o) == scheme_place_object_type) + Scheme_Env *scheme_place_instance_init(); +Scheme_Object *scheme_make_place_object(); void scheme_place_instance_destroy(int force); void scheme_kill_green_thread_timer(); void scheme_place_check_for_interruption(); diff --git a/src/racket/src/schvers.h b/src/racket/src/schvers.h index 497003ffe8..59e0e4d571 100644 --- a/src/racket/src/schvers.h +++ b/src/racket/src/schvers.h @@ -18,7 +18,7 @@ #define MZSCHEME_VERSION_X 5 #define MZSCHEME_VERSION_Y 1 #define MZSCHEME_VERSION_Z 1 -#define MZSCHEME_VERSION_W 8 +#define MZSCHEME_VERSION_W 9 #define MZSCHEME_VERSION_MAJOR ((MZSCHEME_VERSION_X * 100) + MZSCHEME_VERSION_Y) #define MZSCHEME_VERSION_MINOR ((MZSCHEME_VERSION_Z * 1000) + MZSCHEME_VERSION_W) diff --git a/src/racket/src/stypes.h b/src/racket/src/stypes.h index 5d924738a8..58f1af7316 100644 --- a/src/racket/src/stypes.h +++ b/src/racket/src/stypes.h @@ -186,88 +186,89 @@ enum { scheme_flvector_type, /* 166 */ scheme_fxvector_type, /* 167 */ scheme_place_type, /* 168 */ - scheme_place_async_channel_type, /* 169 */ - scheme_place_bi_channel_type, /* 170 */ - scheme_once_used_type, /* 171 */ - scheme_serialized_symbol_type, /* 172 */ - scheme_serialized_structure_type, /* 173 */ + scheme_place_object_type, /* 169 */ + scheme_place_async_channel_type, /* 170 */ + scheme_place_bi_channel_type, /* 171 */ + scheme_once_used_type, /* 172 */ + scheme_serialized_symbol_type, /* 173 */ + scheme_serialized_structure_type, /* 174 */ #ifdef MZTAG_REQUIRED - _scheme_last_normal_type_, /* 174 */ + _scheme_last_normal_type_, /* 175 */ - scheme_rt_weak_array, /* 175 */ + scheme_rt_weak_array, /* 176 */ - scheme_rt_comp_env, /* 168*/ - scheme_rt_constant_binding, /* 177 */ - scheme_rt_resolve_info, /* 178 */ - scheme_rt_optimize_info, /* 179 */ - scheme_rt_compile_info, /* 180 */ - scheme_rt_cont_mark, /* 181 */ - scheme_rt_saved_stack, /* 182 */ - scheme_rt_reply_item, /* 183 */ - scheme_rt_closure_info, /* 184 */ - scheme_rt_overflow, /* 185 */ - scheme_rt_overflow_jmp, /* 186 */ - scheme_rt_meta_cont, /* 187 */ - scheme_rt_dyn_wind_cell, /* 188 */ - scheme_rt_dyn_wind_info, /* 189 */ - scheme_rt_dyn_wind, /* 190 */ - scheme_rt_dup_check, /* 191 */ - scheme_rt_thread_memory, /* 192 */ - scheme_rt_input_file, /* 193 */ - scheme_rt_input_fd, /* 194 */ - scheme_rt_oskit_console_input, /* 195 */ - scheme_rt_tested_input_file, /* 196 */ - scheme_rt_tested_output_file, /* 197 */ - scheme_rt_indexed_string, /* 198 */ - scheme_rt_output_file, /* 199 */ - scheme_rt_load_handler_data, /* 200 */ - scheme_rt_pipe, /* 201 */ - scheme_rt_beos_process, /* 202 */ - scheme_rt_system_child, /* 203 */ - scheme_rt_tcp, /* 204 */ - scheme_rt_write_data, /* 205 */ - scheme_rt_tcp_select_info, /* 206 */ - scheme_rt_param_data, /* 207 */ - scheme_rt_will, /* 208 */ - scheme_rt_struct_proc_info, /* 209 */ - scheme_rt_linker_name, /* 210 */ - scheme_rt_param_map, /* 211 */ - scheme_rt_finalization, /* 212 */ - scheme_rt_finalizations, /* 213 */ - scheme_rt_cpp_object, /* 214 */ - scheme_rt_cpp_array_object, /* 215 */ - scheme_rt_stack_object, /* 216 */ - scheme_rt_preallocated_object, /* 217 */ - scheme_thread_hop_type, /* 218 */ - scheme_rt_srcloc, /* 219 */ - scheme_rt_evt, /* 220 */ - scheme_rt_syncing, /* 221 */ - scheme_rt_comp_prefix, /* 222 */ - scheme_rt_user_input, /* 223 */ - scheme_rt_user_output, /* 224 */ - scheme_rt_compact_port, /* 225 */ - scheme_rt_read_special_dw, /* 226 */ - scheme_rt_regwork, /* 227 */ - scheme_rt_buf_holder, /* 228 */ - scheme_rt_parameterization, /* 229 */ - scheme_rt_print_params, /* 230 */ - scheme_rt_read_params, /* 231 */ - scheme_rt_native_code, /* 232 */ - scheme_rt_native_code_plus_case, /* 233 */ - scheme_rt_jitter_data, /* 234 */ - scheme_rt_module_exports, /* 235 */ - scheme_rt_delay_load_info, /* 236 */ - scheme_rt_marshal_info, /* 237 */ - scheme_rt_unmarshal_info, /* 238 */ - scheme_rt_runstack, /* 239 */ - scheme_rt_sfs_info, /* 240 */ - scheme_rt_validate_clearing, /* 241 */ - scheme_rt_rb_node, /* 242 */ - scheme_rt_lightweight_cont, /* 243 */ + scheme_rt_comp_env, /* 177*/ + scheme_rt_constant_binding, /* 178 */ + scheme_rt_resolve_info, /* 179 */ + scheme_rt_optimize_info, /* 180 */ + scheme_rt_compile_info, /* 181 */ + scheme_rt_cont_mark, /* 182 */ + scheme_rt_saved_stack, /* 183 */ + scheme_rt_reply_item, /* 184 */ + scheme_rt_closure_info, /* 185 */ + scheme_rt_overflow, /* 186 */ + scheme_rt_overflow_jmp, /* 187 */ + scheme_rt_meta_cont, /* 188 */ + scheme_rt_dyn_wind_cell, /* 189 */ + scheme_rt_dyn_wind_info, /* 190 */ + scheme_rt_dyn_wind, /* 191 */ + scheme_rt_dup_check, /* 192 */ + scheme_rt_thread_memory, /* 193 */ + scheme_rt_input_file, /* 194 */ + scheme_rt_input_fd, /* 195 */ + scheme_rt_oskit_console_input, /* 196 */ + scheme_rt_tested_input_file, /* 197 */ + scheme_rt_tested_output_file, /* 198 */ + scheme_rt_indexed_string, /* 199 */ + scheme_rt_output_file, /* 100 */ + scheme_rt_load_handler_data, /* 201 */ + scheme_rt_pipe, /* 202 */ + scheme_rt_beos_process, /* 203 */ + scheme_rt_system_child, /* 204 */ + scheme_rt_tcp, /* 205 */ + scheme_rt_write_data, /* 206 */ + scheme_rt_tcp_select_info, /* 207 */ + scheme_rt_param_data, /* 208 */ + scheme_rt_will, /* 209 */ + scheme_rt_struct_proc_info, /* 210 */ + scheme_rt_linker_name, /* 211 */ + scheme_rt_param_map, /* 212 */ + scheme_rt_finalization, /* 213 */ + scheme_rt_finalizations, /* 214 */ + scheme_rt_cpp_object, /* 215 */ + scheme_rt_cpp_array_object, /* 216 */ + scheme_rt_stack_object, /* 217 */ + scheme_rt_preallocated_object, /* 218 */ + scheme_thread_hop_type, /* 219 */ + scheme_rt_srcloc, /* 220 */ + scheme_rt_evt, /* 221 */ + scheme_rt_syncing, /* 222 */ + scheme_rt_comp_prefix, /* 223 */ + scheme_rt_user_input, /* 224 */ + scheme_rt_user_output, /* 225 */ + scheme_rt_compact_port, /* 226 */ + scheme_rt_read_special_dw, /* 227 */ + scheme_rt_regwork, /* 228 */ + scheme_rt_buf_holder, /* 229 */ + scheme_rt_parameterization, /* 230 */ + scheme_rt_print_params, /* 231 */ + scheme_rt_read_params, /* 232 */ + scheme_rt_native_code, /* 233 */ + scheme_rt_native_code_plus_case, /* 234 */ + scheme_rt_jitter_data, /* 235 */ + scheme_rt_module_exports, /* 236 */ + scheme_rt_delay_load_info, /* 237 */ + scheme_rt_marshal_info, /* 238 */ + scheme_rt_unmarshal_info, /* 239 */ + scheme_rt_runstack, /* 240 */ + scheme_rt_sfs_info, /* 241 */ + scheme_rt_validate_clearing, /* 242 */ + scheme_rt_rb_node, /* 243 */ + scheme_rt_lightweight_cont, /* 244 */ #endif - scheme_fsemaphore_type, /* 244 */ + scheme_fsemaphore_type, /* 245 */ _scheme_last_type_ };