scheduler.h

Go to the documentation of this file.

#ifndef RUBY_FIBER_SCHEDULER_H                       /*-*-C++-*-vi:se ft=cpp:*/
#define RUBY_FIBER_SCHEDULER_H
#include "ruby/internal/config.h"
 
#include <errno.h>
 
#ifdef STDC_HEADERS
#include <stddef.h> /* size_t */
#endif
 
#include "ruby/ruby.h"
#include "ruby/internal/dllexport.h"
#include "ruby/internal/arithmetic.h"
 
RBIMPL_SYMBOL_EXPORT_BEGIN()
 
// Version 3: Adds support for `fiber_interrupt`.
// Version 4: IO hooks use single-transfer `(offset, length)` semantics.
// Version 5: `fiber_interrupt` may receive an operation-scoped proxy.
#define RUBY_FIBER_SCHEDULER_VERSION 5
 
struct timeval;
struct rb_thread_struct;
 
static inline VALUE
rb_fiber_scheduler_io_result(ssize_t result, int error)
{
    if (result == -1) {
        return RB_INT2NUM(-error);
    }
    else {
        return RB_SIZE2NUM(result);
    }
}
 
static inline ssize_t
rb_fiber_scheduler_io_result_apply(VALUE result)
{
    if (RB_FIXNUM_P(result) && RB_NUM2INT(result) < 0) {
        errno = -RB_NUM2INT(result);
        return -1;
    }
    else {
        return RB_NUM2SIZE(result);
    }
}
 
VALUE rb_fiber_scheduler_get(void);
 
VALUE rb_fiber_scheduler_set(VALUE scheduler);
 
VALUE rb_fiber_scheduler_current(void);
 
VALUE rb_fiber_scheduler_current_for_thread(VALUE thread);
 
VALUE rb_fiber_scheduler_current_for_threadptr(struct rb_thread_struct *thread);
 
VALUE rb_fiber_scheduler_make_timeout(struct timeval *timeout);
 
VALUE rb_fiber_scheduler_close(VALUE scheduler);
 
VALUE rb_fiber_scheduler_kernel_sleep(VALUE scheduler, VALUE duration);
 
VALUE rb_fiber_scheduler_kernel_sleepv(VALUE scheduler, int argc, VALUE * argv);
 
VALUE rb_fiber_scheduler_yield(VALUE scheduler);
 
/* Description TBW */
#if 0
VALUE rb_fiber_scheduler_timeout_after(VALUE scheduler, VALUE timeout, VALUE exception, VALUE message);
VALUE rb_fiber_scheduler_timeout_afterv(VALUE scheduler, int argc, VALUE * argv);
int rb_fiber_scheduler_supports_process_wait(VALUE scheduler);
#endif
 
VALUE rb_fiber_scheduler_process_wait(VALUE scheduler, rb_pid_t pid, int flags);
 
VALUE rb_fiber_scheduler_block(VALUE scheduler, VALUE blocker, VALUE timeout);
 
VALUE rb_fiber_scheduler_unblock(VALUE scheduler, VALUE blocker, VALUE fiber);
 
VALUE rb_fiber_scheduler_io_wait(VALUE scheduler, VALUE io, VALUE events, VALUE timeout);
 
VALUE rb_fiber_scheduler_io_wait_readable(VALUE scheduler, VALUE io);
 
VALUE rb_fiber_scheduler_io_wait_writable(VALUE scheduler, VALUE io);
 
VALUE rb_fiber_scheduler_io_select(VALUE scheduler, VALUE readables, VALUE writables, VALUE exceptables, VALUE timeout);
 
VALUE rb_fiber_scheduler_io_selectv(VALUE scheduler, int argc, VALUE *argv);
 
VALUE rb_fiber_scheduler_io_read(VALUE scheduler, VALUE io, VALUE buffer, size_t offset, size_t length);
 
VALUE rb_fiber_scheduler_io_write(VALUE scheduler, VALUE io, VALUE buffer, size_t offset, size_t length);
 
VALUE rb_fiber_scheduler_io_pread(VALUE scheduler, VALUE io, rb_off_t from, VALUE buffer, size_t offset, size_t length);
 
VALUE rb_fiber_scheduler_io_pwrite(VALUE scheduler, VALUE io, rb_off_t from, VALUE buffer, size_t offset, size_t length);
 
VALUE rb_fiber_scheduler_io_read_memory(VALUE scheduler, VALUE io, void *base, size_t size);
 
VALUE rb_fiber_scheduler_io_write_memory(VALUE scheduler, VALUE io, const void *base, size_t size);
 
VALUE rb_fiber_scheduler_io_pread_memory(VALUE scheduler, VALUE io, rb_off_t from, void *base, size_t size);
 
VALUE rb_fiber_scheduler_io_pwrite_memory(VALUE scheduler, VALUE io, rb_off_t from, const void *base, size_t size);
 
VALUE rb_fiber_scheduler_io_close(VALUE scheduler, VALUE io);
 
VALUE rb_fiber_scheduler_address_resolve(VALUE scheduler, VALUE hostname);
 
// The state of the blocking operation execution.
struct rb_fiber_scheduler_blocking_operation_state {
    void *result;
    int saved_errno;
};
 
// The opaque handle for the blocking operation.
typedef struct rb_fiber_scheduler_blocking_operation rb_fiber_scheduler_blocking_operation_t;
 
rb_fiber_scheduler_blocking_operation_t *rb_fiber_scheduler_blocking_operation_extract(VALUE self);
 
int rb_fiber_scheduler_blocking_operation_execute(rb_fiber_scheduler_blocking_operation_t *blocking_operation);
 
int rb_fiber_scheduler_blocking_operation_cancel(rb_fiber_scheduler_blocking_operation_t *blocking_operation);
 
VALUE rb_fiber_scheduler_blocking_operation_wait(VALUE scheduler, void* (*function)(void *), void *data, rb_unblock_function_t *unblock_function, void *data2, int flags, struct rb_fiber_scheduler_blocking_operation_state *state);
 
VALUE rb_fiber_scheduler_fiber_interrupt(VALUE scheduler, VALUE target, VALUE exception);
 
VALUE rb_fiber_scheduler_fiber(VALUE scheduler, int argc, VALUE *argv, int kw_splat);
 
RBIMPL_SYMBOL_EXPORT_END()
 
#endif /* RUBY_FIBER_SCHEDULER_H */