static void run_gc(MVMThreadContext *tc, MVMuint8 what_to_do) {
MVMuint8 gen;
MVMuint32 i, n;
unsigned int interval_id;
#if MVM_GC_DEBUG
if (tc->in_spesh)
MVM_panic(1, "Must not GC when in the specializer/JIT\n");
#endif
/* Decide nursery or full collection. */
gen = tc->instance->gc_full_collect ? MVMGCGenerations_Both : MVMGCGenerations_Nursery;
if (tc->instance->gc_full_collect) {
interval_id = MVM_telemetry_interval_start(tc, "start full collection");
} else {
interval_id = MVM_telemetry_interval_start(tc, "start minor collection");
}
/* Do GC work for ourselves and any work threads. */
for (i = 0, n = tc->gc_work_count ; i < n; i++) {
MVMThreadContext *other = tc->gc_work[i].tc;
tc->gc_work[i].limit = other->nursery_alloc;
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : starting collection for thread %d\n",
other->thread_id);
other->gc_promoted_bytes = 0;
MVM_gc_collect(other, (other == tc ? what_to_do : MVMGCWhatToDo_NoInstance), gen);
}
/* Wait for everybody to agree we're done. */
finish_gc(tc, gen, what_to_do == MVMGCWhatToDo_All);
MVM_telemetry_interval_stop(tc, interval_id, "finished run_gc");
}
static MVMObject * socket_accept(MVMThreadContext *tc, MVMOSHandle *h) {
MVMIOSyncSocketData *data = (MVMIOSyncSocketData *)h->body.data;
Socket s;
unsigned int interval_id = MVM_telemetry_interval_start(tc, "syncsocket accept");
do {
MVM_gc_mark_thread_blocked(tc);
s = accept(data->handle, NULL, NULL);
MVM_gc_mark_thread_unblocked(tc);
} while(s == -1 && errno == EINTR);
if (MVM_IS_SOCKET_ERROR(s)) {
MVM_telemetry_interval_stop(tc, interval_id, "syncsocket accept failed");
throw_error(tc, s, "accept socket connection");
}
else {
MVMOSHandle * const result = (MVMOSHandle *)MVM_repr_alloc_init(tc,
tc->instance->boot_types.BOOTIO);
MVMIOSyncSocketData * const data = MVM_calloc(1, sizeof(MVMIOSyncSocketData));
data->handle = s;
result->body.ops = &op_table;
result->body.data = data;
MVM_telemetry_interval_stop(tc, interval_id, "syncsocket accept succeeded");
return (MVMObject *)result;
}
}
/* Reads the specified number of bytes into a the supplied buffer, returning
* the number actually read. */
static MVMint64 read_bytes(MVMThreadContext *tc, MVMOSHandle *h, char **buf_out, MVMint64 bytes) {
MVMIOFileData *data = (MVMIOFileData *)h->body.data;
char *buf = MVM_malloc(bytes);
unsigned int interval_id = MVM_telemetry_interval_start(tc, "syncfile.read_to_buffer");
MVMint32 bytes_read;
#ifdef _WIN32
/* Can only perform relatively small reads from a Windows console;
* trying to do larger ones gives back ENOMEM, most likely due to
* limitations of the Windows console subsystem. */
if (bytes > 16387 && _isatty(data->fd))
bytes = 16387;
#endif
flush_output_buffer(tc, data);
MVM_gc_mark_thread_blocked(tc);
if ((bytes_read = read(data->fd, buf, bytes)) == -1) {
int save_errno = errno;
MVM_free(buf);
MVM_gc_mark_thread_unblocked(tc);
MVM_exception_throw_adhoc(tc, "Reading from filehandle failed: %s",
strerror(save_errno));
}
*buf_out = buf;
MVM_gc_mark_thread_unblocked(tc);
MVM_telemetry_interval_annotate(bytes_read, interval_id, "read this many bytes");
MVM_telemetry_interval_stop(tc, interval_id, "syncfile.read_to_buffer");
data->byte_position += bytes_read;
if (bytes_read == 0 && bytes != 0)
data->eof_reported = 1;
return bytes_read;
}
/* Establishes a connection. */
static void socket_connect(MVMThreadContext *tc, MVMOSHandle *h, MVMString *host, MVMint64 port) {
MVMIOSyncSocketData *data = (MVMIOSyncSocketData *)h->body.data;
unsigned int interval_id;
interval_id = MVM_telemetry_interval_start(tc, "syncsocket connect");
if (!data->handle) {
struct sockaddr *dest = MVM_io_resolve_host_name(tc, host, port);
int r;
Socket s = socket(dest->sa_family , SOCK_STREAM , 0);
if (MVM_IS_SOCKET_ERROR(s)) {
MVM_free(dest);
MVM_telemetry_interval_stop(tc, interval_id, "syncsocket connect");
throw_error(tc, s, "create socket");
}
do {
MVM_gc_mark_thread_blocked(tc);
r = connect(s, dest, (socklen_t)get_struct_size_for_family(dest->sa_family));
MVM_gc_mark_thread_unblocked(tc);
} while(r == -1 && errno == EINTR);
MVM_free(dest);
if (MVM_IS_SOCKET_ERROR(r)) {
MVM_telemetry_interval_stop(tc, interval_id, "syncsocket connect");
throw_error(tc, s, "connect socket");
}
data->handle = s;
}
else {
MVM_telemetry_interval_stop(tc, interval_id, "syncsocket didn't connect");
MVM_exception_throw_adhoc(tc, "Socket is already bound or connected");
}
}
/* Writes the specified bytes to the stream. */
MVMint64 socket_write_bytes(MVMThreadContext *tc, MVMOSHandle *h, char *buf, MVMint64 bytes) {
MVMIOSyncSocketData *data = (MVMIOSyncSocketData *)h->body.data;
MVMint64 sent = 0;
unsigned int interval_id;
interval_id = MVM_telemetry_interval_start(tc, "syncsocket.write_bytes");
MVM_gc_mark_thread_blocked(tc);
while (bytes > 0) {
int r;
do {
r = send(data->handle, buf, (int)bytes, 0);
} while(r == -1 && errno == EINTR);
if (MVM_IS_SOCKET_ERROR(r)) {
MVM_gc_mark_thread_unblocked(tc);
MVM_telemetry_interval_stop(tc, interval_id, "syncsocket.write_bytes");
throw_error(tc, r, "send data to socket");
}
sent += r;
buf += r;
bytes -= r;
}
MVM_gc_mark_thread_unblocked(tc);
MVM_telemetry_interval_annotate(bytes, interval_id, "written this many bytes");
MVM_telemetry_interval_stop(tc, interval_id, "syncsocket.write_bytes");
return bytes;
}
/* Creates a new thread handle with the MVMThread representation. Does not
* actually start execution of the thread, but does give it its unique ID. */
MVMObject * MVM_thread_new(MVMThreadContext *tc, MVMObject *invokee, MVMint64 app_lifetime) {
MVMThread *thread;
MVMThreadContext *child_tc;
unsigned int interval_id;
interval_id = MVM_telemetry_interval_start(tc, "spawning a new thread off of me");
/* Create the Thread object and stash code to run and lifetime. */
MVMROOT(tc, invokee, {
thread = (MVMThread *)MVM_repr_alloc_init(tc, tc->instance->Thread);
});
/* Read a packet worth of data into the last packet buffer. */
static void read_one_packet(MVMThreadContext *tc, MVMIOSyncSocketData *data) {
unsigned int interval_id = MVM_telemetry_interval_start(tc, "syncsocket.read_one_packet");
int r;
data->last_packet = MVM_malloc(PACKET_SIZE);
do {
MVM_gc_mark_thread_blocked(tc);
r = recv(data->handle, data->last_packet, PACKET_SIZE, 0);
MVM_gc_mark_thread_unblocked(tc);
} while(r == -1 && errno == EINTR);
MVM_telemetry_interval_stop(tc, interval_id, "syncsocket.read_one_packet");
if (MVM_IS_SOCKET_ERROR(r) || r == 0) {
MVM_free(data->last_packet);
data->last_packet = NULL;
if (r != 0)
throw_error(tc, r, "receive data from socket");
}
else {
data->last_packet_start = 0;
data->last_packet_end = r;
}
}
static void callback_handler(ffi_cif *cif, void *cb_result, void **cb_args, void *cb_data) {
CallbackInvokeData cid;
MVMint32 num_roots, i;
MVMRegister res;
MVMRegister *args;
MVMNativeCallback *data = (MVMNativeCallback *)cb_data;
void **values = MVM_malloc(sizeof(void *) * (data->cs->arg_count ? data->cs->arg_count : 1));
unsigned int interval_id;
/* Locate the MoarVM thread this callback is being run on. */
MVMThreadContext *tc = MVM_nativecall_find_thread_context(data->instance);
/* Unblock GC if needed, so this thread can do work. */
MVMint32 was_blocked = MVM_gc_is_thread_blocked(tc);
if (was_blocked)
MVM_gc_mark_thread_unblocked(tc);
interval_id = MVM_telemetry_interval_start(tc, "nativecall callback handler");
/* Build a callsite and arguments buffer. */
args = MVM_malloc(data->num_types * sizeof(MVMRegister));
num_roots = 0;
for (i = 1; i < data->num_types; i++) {
MVMObject *type = data->types[i];
MVMint16 typeinfo = data->typeinfos[i];
switch (typeinfo & MVM_NATIVECALL_ARG_TYPE_MASK) {
case MVM_NATIVECALL_ARG_CHAR:
args[i - 1].i64 = *(signed char *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_SHORT:
args[i - 1].i64 = *(signed short *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_INT:
args[i - 1].i64 = *(signed int *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_LONG:
args[i - 1].i64 = *(signed long *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_LONGLONG:
args[i - 1].i64 = *(signed long long *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_FLOAT:
args[i - 1].n64 = *(float *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_DOUBLE:
args[i - 1].n64 = *(double *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_ASCIISTR:
case MVM_NATIVECALL_ARG_UTF8STR:
case MVM_NATIVECALL_ARG_UTF16STR:
args[i - 1].o = MVM_nativecall_make_str(tc, type, typeinfo, *(char **)cb_args[i - 1]);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CSTRUCT:
args[i - 1].o = MVM_nativecall_make_cstruct(tc, type, *(void **)cb_args[i - 1]);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CPPSTRUCT:
args[i - 1].o = MVM_nativecall_make_cppstruct(tc, type, *(void **)cb_args[i - 1]);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CPOINTER:
args[i - 1].o = MVM_nativecall_make_cpointer(tc, type, *(void **)cb_args[i - 1]);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CARRAY:
args[i - 1].o = MVM_nativecall_make_carray(tc, type, *(void **)cb_args[i - 1]);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CUNION:
args[i - 1].o = MVM_nativecall_make_cunion(tc, type, *(void **)cb_args[i - 1]);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CALLBACK:
/* TODO: A callback -return- value means that we have a C method
* that needs to be wrapped similarly to a is native(...) Perl 6
* sub. */
/* XXX do something with the function pointer: *(void **)cb_args[i - 1] */
args[i - 1].o = type;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
case MVM_NATIVECALL_ARG_UCHAR:
args[i - 1].i64 = *(unsigned char *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_USHORT:
args[i - 1].i64 = *(unsigned short *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_UINT:
args[i - 1].i64 = *(unsigned int *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_ULONG:
args[i - 1].i64 = *(unsigned long *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_ULONGLONG:
args[i - 1].i64 = *(unsigned long long *)cb_args[i - 1];
break;
default:
MVM_telemetry_interval_stop(tc, interval_id, "nativecall callback handler failed");
MVM_exception_throw_adhoc(tc,
"Internal error: unhandled libffi callback argument type");
}
}
/* Call into a nested interpreter (since we already are in one). Need to
* save a bunch of state around each side of this. */
cid.invokee = data->target;
cid.args = args;
cid.cs = data->cs;
{
MVMuint8 **backup_interp_cur_op = tc->interp_cur_op;
MVMuint8 **backup_interp_bytecode_start = tc->interp_bytecode_start;
MVMRegister **backup_interp_reg_base = tc->interp_reg_base;
MVMCompUnit **backup_interp_cu = tc->interp_cu;
MVMFrame *backup_cur_frame = MVM_frame_force_to_heap(tc, tc->cur_frame);
MVMFrame *backup_thread_entry_frame = tc->thread_entry_frame;
void **backup_jit_return_address = tc->jit_return_address;
tc->jit_return_address = NULL;
MVMROOT2(tc, backup_cur_frame, backup_thread_entry_frame, {
MVMuint32 backup_mark = MVM_gc_root_temp_mark(tc);
jmp_buf backup_interp_jump;
memcpy(backup_interp_jump, tc->interp_jump, sizeof(jmp_buf));
tc->cur_frame->return_value = &res;
tc->cur_frame->return_type = MVM_RETURN_OBJ;
MVM_interp_run(tc, callback_invoke, &cid);
tc->interp_cur_op = backup_interp_cur_op;
tc->interp_bytecode_start = backup_interp_bytecode_start;
tc->interp_reg_base = backup_interp_reg_base;
tc->interp_cu = backup_interp_cu;
tc->cur_frame = backup_cur_frame;
tc->current_frame_nr = backup_cur_frame->sequence_nr;
tc->thread_entry_frame = backup_thread_entry_frame;
tc->jit_return_address = backup_jit_return_address;
memcpy(tc->interp_jump, backup_interp_jump, sizeof(jmp_buf));
MVM_gc_root_temp_mark_reset(tc, backup_mark);
});
}
/* Enters the work loop. */
static void worker(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) {
MVMObject *updated_static_frames = MVM_repr_alloc_init(tc,
tc->instance->boot_types.BOOTArray);
MVMObject *previous_static_frames = MVM_repr_alloc_init(tc,
tc->instance->boot_types.BOOTArray);
tc->instance->speshworker_thread_id = tc->thread_obj->body.thread_id;
MVMROOT2(tc, updated_static_frames, previous_static_frames, {
while (1) {
MVMObject *log_obj;
MVMuint64 start_time;
unsigned int interval_id;
if (MVM_spesh_debug_enabled(tc))
start_time = uv_hrtime();
log_obj = MVM_repr_shift_o(tc, tc->instance->spesh_queue);
if (MVM_spesh_debug_enabled(tc)) {
MVM_spesh_debug_printf(tc,
"Received Logs\n"
"=============\n\n"
"Was waiting %dus for logs on the log queue.\n\n",
(int)((uv_hrtime() - start_time) / 1000));
}
if (tc->instance->main_thread->prof_data)
MVM_profiler_log_spesh_start(tc);
interval_id = MVM_telemetry_interval_start(tc, "spesh worker consuming a log");
uv_mutex_lock(&(tc->instance->mutex_spesh_sync));
tc->instance->spesh_working = 1;
uv_mutex_unlock(&(tc->instance->mutex_spesh_sync));
tc->instance->spesh_stats_version++;
if (log_obj->st->REPR->ID == MVM_REPR_ID_MVMSpeshLog) {
MVMSpeshLog *sl = (MVMSpeshLog *)log_obj;
MVM_telemetry_interval_annotate((uintptr_t)sl->body.thread->body.tc, interval_id, "from this thread");
MVMROOT(tc, sl, {
MVMThreadContext *stc;
MVMuint32 i;
MVMuint32 n;
/* Update stats, and if we're logging dump each of them. */
tc->instance->spesh_stats_version++;
if (MVM_spesh_debug_enabled(tc))
start_time = uv_hrtime();
MVM_spesh_stats_update(tc, sl, updated_static_frames);
n = MVM_repr_elems(tc, updated_static_frames);
if (MVM_spesh_debug_enabled(tc)) {
MVM_spesh_debug_printf(tc,
"Statistics Updated\n"
"==================\n"
"%d frames had their statistics updated in %dus.\n\n",
(int)n, (int)((uv_hrtime() - start_time) / 1000));
for (i = 0; i < n; i++) {
char *dump = MVM_spesh_dump_stats(tc, (MVMStaticFrame* )
MVM_repr_at_pos_o(tc, updated_static_frames, i));
MVM_spesh_debug_printf(tc, "%s==========\n\n", dump);
MVM_free(dump);
}
}
MVM_telemetry_interval_annotate((uintptr_t)n, interval_id, "stats for this many frames");
GC_SYNC_POINT(tc);
/* Form a specialization plan. */
if (MVM_spesh_debug_enabled(tc))
start_time = uv_hrtime();
tc->instance->spesh_plan = MVM_spesh_plan(tc, updated_static_frames);
if (MVM_spesh_debug_enabled(tc)) {
n = tc->instance->spesh_plan->num_planned;
MVM_spesh_debug_printf(tc,
"Specialization Plan\n"
"===================\n"
"%u specialization(s) will be produced (planned in %dus).\n\n",
n, (int)((uv_hrtime() - start_time) / 1000));
for (i = 0; i < n; i++) {
char *dump = MVM_spesh_dump_planned(tc,
&(tc->instance->spesh_plan->planned[i]));
MVM_spesh_debug_printf(tc, "%s==========\n\n", dump);
MVM_free(dump);
}
}
MVM_telemetry_interval_annotate((uintptr_t)tc->instance->spesh_plan->num_planned, interval_id,
"this many specializations planned");
GC_SYNC_POINT(tc);
/* Implement the plan and then discard it. */
n = tc->instance->spesh_plan->num_planned;
for (i = 0; i < n; i++) {
MVM_spesh_candidate_add(tc, &(tc->instance->spesh_plan->planned[i]));
GC_SYNC_POINT(tc);
}
MVM_spesh_plan_destroy(tc, tc->instance->spesh_plan);
tc->instance->spesh_plan = NULL;
/* Clear up stats that didn't get updated for a while,
* then add frames updated this time into the previously
* updated array. */
MVM_spesh_stats_cleanup(tc, previous_static_frames);
n = MVM_repr_elems(tc, updated_static_frames);
for (i = 0; i < n; i++)
MVM_repr_push_o(tc, previous_static_frames,
MVM_repr_at_pos_o(tc, updated_static_frames, i));
/* Clear updated static frames array. */
MVM_repr_pos_set_elems(tc, updated_static_frames, 0);
/* Allow the sending thread to produce more logs again,
* putting a new spesh log in place if needed. */
stc = sl->body.thread->body.tc;
if (stc && !sl->body.was_compunit_bumped)
if (MVM_incr(&(stc->spesh_log_quota)) == 0) {
stc->spesh_log = MVM_spesh_log_create(tc, sl->body.thread);
MVM_telemetry_timestamp(stc, "logging restored after quota had run out");
}
/* If needed, signal sending thread that it can continue. */
if (sl->body.block_mutex) {
uv_mutex_lock(sl->body.block_mutex);
MVM_store(&(sl->body.completed), 1);
uv_cond_signal(sl->body.block_condvar);
uv_mutex_unlock(sl->body.block_mutex);
}
{
MVMSpeshLogEntry *entries = sl->body.entries;
sl->body.entries = NULL;
MVM_free(entries);
}
});
}
else if (MVM_is_null(tc, log_obj)) {
