ruby/scheduler.c

242 строки
5.6 KiB
C
Исходник Обычный вид История

2020-08-20 04:51:45 +03:00
/**********************************************************************
scheduler.c
$Author$
Copyright (C) 2020 Samuel Grant Dawson Williams
**********************************************************************/
2020-10-16 04:25:58 +03:00
#include "vm_core.h"
#include "ruby/fiber/scheduler.h"
2020-08-20 04:51:45 +03:00
#include "ruby/io.h"
static ID id_close;
static ID id_block;
static ID id_unblock;
static ID id_timeout_after;
static ID id_kernel_sleep;
static ID id_process_wait;
2020-08-20 04:51:45 +03:00
static ID id_io_read;
static ID id_io_write;
static ID id_io_wait;
static ID id_address_resolve;
2020-08-20 04:51:45 +03:00
void
Init_Fiber_Scheduler(void)
2020-08-20 04:51:45 +03:00
{
id_close = rb_intern_const("close");
id_block = rb_intern_const("block");
id_unblock = rb_intern_const("unblock");
id_timeout_after = rb_intern_const("timeout_after");
id_kernel_sleep = rb_intern_const("kernel_sleep");
id_process_wait = rb_intern_const("process_wait");
2020-08-20 04:51:45 +03:00
id_io_read = rb_intern_const("io_read");
id_io_write = rb_intern_const("io_write");
id_io_wait = rb_intern_const("io_wait");
id_address_resolve = rb_intern_const("address_resolve");
2020-08-20 04:51:45 +03:00
}
2020-10-16 04:25:58 +03:00
VALUE
rb_fiber_scheduler_get(void)
2020-10-16 04:25:58 +03:00
{
rb_thread_t *thread = GET_THREAD();
VM_ASSERT(thread);
return thread->scheduler;
}
static void
verify_interface(VALUE scheduler)
{
if (!rb_respond_to(scheduler, id_block)) {
rb_raise(rb_eArgError, "Scheduler must implement #block");
}
if (!rb_respond_to(scheduler, id_unblock)) {
rb_raise(rb_eArgError, "Scheduler must implement #unblock");
}
if (!rb_respond_to(scheduler, id_kernel_sleep)) {
rb_raise(rb_eArgError, "Scheduler must implement #kernel_sleep");
}
if (!rb_respond_to(scheduler, id_io_wait)) {
rb_raise(rb_eArgError, "Scheduler must implement #io_wait");
}
}
2020-10-16 04:25:58 +03:00
VALUE
rb_fiber_scheduler_set(VALUE scheduler)
2020-10-16 04:25:58 +03:00
{
rb_thread_t *thread = GET_THREAD();
VM_ASSERT(thread);
if (scheduler != Qnil) {
verify_interface(scheduler);
}
2020-10-16 04:25:58 +03:00
// We invoke Scheduler#close when setting it to something else, to ensure the previous scheduler runs to completion before changing the scheduler. That way, we do not need to consider interactions, e.g., of a Fiber from the previous scheduler with the new scheduler.
if (thread->scheduler != Qnil) {
rb_fiber_scheduler_close(thread->scheduler);
2020-10-16 04:25:58 +03:00
}
thread->scheduler = scheduler;
return thread->scheduler;
}
static VALUE
rb_fiber_scheduler_current_for_threadptr(rb_thread_t *thread)
2020-10-16 04:25:58 +03:00
{
VM_ASSERT(thread);
if (thread->blocking == 0) {
return thread->scheduler;
}
else {
2020-10-16 04:25:58 +03:00
return Qnil;
}
}
VALUE
rb_fiber_scheduler_current(void)
2020-10-16 04:25:58 +03:00
{
return rb_fiber_scheduler_current_for_threadptr(GET_THREAD());
2020-10-16 04:25:58 +03:00
}
VALUE rb_fiber_scheduler_current_for_thread(VALUE thread)
2020-10-16 04:25:58 +03:00
{
return rb_fiber_scheduler_current_for_threadptr(rb_thread_ptr(thread));
2020-10-16 04:25:58 +03:00
}
VALUE
rb_fiber_scheduler_close(VALUE scheduler)
{
if (rb_respond_to(scheduler, id_close)) {
return rb_funcall(scheduler, id_close, 0);
}
2020-10-01 07:45:50 +03:00
return Qnil;
}
2020-08-20 04:51:45 +03:00
VALUE
rb_fiber_scheduler_make_timeout(struct timeval *timeout)
{
2020-08-20 04:51:45 +03:00
if (timeout) {
return rb_float_new((double)timeout->tv_sec + (0.000001f * timeout->tv_usec));
}
return Qnil;
}
VALUE
2021-03-30 07:33:15 +03:00
rb_fiber_scheduler_kernel_sleep(VALUE scheduler, VALUE timeout)
{
2021-03-30 07:33:15 +03:00
return rb_funcall(scheduler, id_kernel_sleep, 1, timeout);
}
2021-02-11 09:17:54 +03:00
VALUE
2021-03-30 07:33:15 +03:00
rb_fiber_scheduler_kernel_sleepv(VALUE scheduler, int argc, VALUE * argv)
2021-02-11 09:17:54 +03:00
{
2021-03-30 07:33:15 +03:00
return rb_funcallv(scheduler, id_kernel_sleep, argc, argv);
2021-02-11 09:17:54 +03:00
}
2021-03-30 07:33:15 +03:00
#if 0
VALUE
2021-03-30 07:33:15 +03:00
rb_fiber_scheduler_timeout_after(VALUE scheduler, VALUE timeout, VALUE exception, VALUE message)
2020-08-20 04:51:45 +03:00
{
2021-03-30 07:33:15 +03:00
VALUE arguments[] = {
timeout, exception, message
};
return rb_check_funcall(scheduler, id_timeout_after, 3, arguments);
2020-08-20 04:51:45 +03:00
}
VALUE
2021-03-30 07:33:15 +03:00
rb_fiber_scheduler_timeout_afterv(VALUE scheduler, int argc, VALUE * argv)
2020-08-20 04:51:45 +03:00
{
2021-03-30 07:33:15 +03:00
return rb_check_funcall(scheduler, id_timeout_after, argc, argv);
2020-08-20 04:51:45 +03:00
}
2021-03-30 07:33:15 +03:00
#endif
2020-08-20 04:51:45 +03:00
VALUE
rb_fiber_scheduler_process_wait(VALUE scheduler, rb_pid_t pid, int flags)
{
VALUE arguments[] = {
PIDT2NUM(pid), RB_INT2NUM(flags)
};
2021-02-09 10:59:15 +03:00
return rb_check_funcall(scheduler, id_process_wait, 2, arguments);
}
VALUE
rb_fiber_scheduler_block(VALUE scheduler, VALUE blocker, VALUE timeout)
{
2020-09-21 00:54:08 +03:00
return rb_funcall(scheduler, id_block, 2, blocker, timeout);
}
VALUE
rb_fiber_scheduler_unblock(VALUE scheduler, VALUE blocker, VALUE fiber)
{
return rb_funcall(scheduler, id_unblock, 2, blocker, fiber);
}
VALUE
rb_fiber_scheduler_io_wait(VALUE scheduler, VALUE io, VALUE events, VALUE timeout)
2020-08-20 04:51:45 +03:00
{
return rb_funcall(scheduler, id_io_wait, 3, io, events, timeout);
}
VALUE
rb_fiber_scheduler_io_wait_readable(VALUE scheduler, VALUE io)
2020-08-20 04:51:45 +03:00
{
return rb_fiber_scheduler_io_wait(scheduler, io, RB_UINT2NUM(RUBY_IO_READABLE), Qnil);
2020-08-20 04:51:45 +03:00
}
VALUE
rb_fiber_scheduler_io_wait_writable(VALUE scheduler, VALUE io)
2020-08-20 04:51:45 +03:00
{
return rb_fiber_scheduler_io_wait(scheduler, io, RB_UINT2NUM(RUBY_IO_WRITABLE), Qnil);
2020-08-20 04:51:45 +03:00
}
VALUE
rb_fiber_scheduler_io_read(VALUE scheduler, VALUE io, VALUE buffer, size_t offset, size_t length)
2020-08-20 15:53:08 +03:00
{
VALUE arguments[] = {
io, buffer, SIZET2NUM(offset), SIZET2NUM(length)
};
2021-02-09 10:59:15 +03:00
return rb_check_funcall(scheduler, id_io_read, 4, arguments);
2020-08-20 15:53:08 +03:00
}
VALUE
rb_fiber_scheduler_io_write(VALUE scheduler, VALUE io, VALUE buffer, size_t offset, size_t length)
2020-08-20 04:51:45 +03:00
{
VALUE arguments[] = {
io, buffer, SIZET2NUM(offset), SIZET2NUM(length)
};
2020-08-20 04:51:45 +03:00
// We should ensure string has capacity to receive data, and then resize it afterwards.
return rb_check_funcall(scheduler, id_io_write, 4, arguments);
2020-08-20 04:51:45 +03:00
}
VALUE
rb_fiber_scheduler_address_resolve(VALUE scheduler, VALUE hostname)
{
VALUE arguments[] = {
hostname
};
return rb_check_funcall(scheduler, id_address_resolve, 1, arguments);
}