suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Scheme_Place_Object is now under gc control, multiple places can wait on a place channel.

Browse Source
This commit is contained in:
Kevin Tew 2011-07-06 11:22:26 -06:00
parent ff49859c80
commit 36e3679854
8 changed files with 326 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
collects/tests/racket/place-channel.rkt
View File

@ -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))

9
src/racket/src/env.c
View File

@ -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

21
src/racket/src/mzmark_place.inc
View File

@ -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));

7
src/racket/src/mzmarksrc.c
View File

@ -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;

206
src/racket/src/place.c
View File

@ -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);
}

14
src/racket/src/schpriv.h
View File

@ -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();

2
src/racket/src/schvers.h
View File

@ -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)

153
src/racket/src/stypes.h
View File

@ -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_
};