farce 0 → 0.1.0

data/ext/farce/unshareable.c

@@ -0,0 +1,155 @@
+#include "containers.h"
+
+typedef struct {
+    unsigned char reserved;
+} containers_pin_marker_t;
+
+static ID pin_marker_id;
+static ID copy_marker_id;
+static ID move_marker_id;
+static ID pipe_id;
+static ID close_id;
+static VALUE cPinMarker;
+static VALUE eIsolationError;
+
+static size_t
+containers_pin_marker_size(const void *pointer)
+{
+    return pointer == NULL ? 0 : sizeof(containers_pin_marker_t);
+}
+
+static const rb_data_type_t containers_pin_marker_type = {
+    .wrap_struct_name = "Ractor::Containers pin marker",
+    .function = {
+        .dmark = NULL,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = containers_pin_marker_size,
+        .dcompact = NULL,
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static bool
+containers_pin_marker_p(VALUE value)
+{
+    return !NIL_P(value) && rb_typeddata_is_kind_of(value, &containers_pin_marker_type);
+}
+
+static void
+containers_check_guard_target(VALUE object)
+{
+    if (RB_SPECIAL_CONST_P(object)) {
+        rb_raise(rb_eTypeError, "cannot guard an immediate value");
+    }
+
+    rb_check_frozen(object);
+    if (rb_ractor_shareable_p(object)) {
+        rb_raise(eIsolationError, "cannot guard an object that is already shareable");
+    }
+}
+
+static VALUE
+containers_new_pin_marker(void)
+{
+    containers_pin_marker_t *marker_data;
+    VALUE marker = TypedData_Make_Struct(
+        cPinMarker,
+        containers_pin_marker_t,
+        &containers_pin_marker_type,
+        marker_data
+    );
+    marker_data->reserved = 0;
+    rb_obj_freeze(marker);
+    return marker;
+}
+
+static VALUE
+containers_new_copy_marker(void)
+{
+    VALUE pair = rb_funcall(rb_cIO, pipe_id, 0);
+    VALUE reader = rb_ary_entry(pair, 0);
+    VALUE writer = rb_ary_entry(pair, 1);
+
+    rb_funcall(reader, close_id, 0);
+    rb_funcall(writer, close_id, 0);
+    return reader;
+}
+
+static VALUE
+containers_unshareable_pin(VALUE module, VALUE object)
+{
+    VALUE marker;
+    (void)module;
+
+    if (RB_SPECIAL_CONST_P(object)) {
+        rb_raise(rb_eTypeError, "cannot guard an immediate value");
+    }
+
+    marker = rb_ivar_get(object, pin_marker_id);
+    if (containers_pin_marker_p(marker)) return object;
+
+    containers_check_guard_target(object);
+    rb_ivar_set(object, pin_marker_id, containers_new_pin_marker());
+    return object;
+}
+
+static VALUE
+containers_unshareable_prevent_copyable(VALUE module, VALUE object)
+{
+    VALUE marker;
+    (void)module;
+
+    if (RB_SPECIAL_CONST_P(object)) {
+        rb_raise(rb_eTypeError, "cannot guard an immediate value");
+    }
+
+    if (containers_pin_marker_p(rb_ivar_get(object, pin_marker_id))) return object;
+    marker = rb_ivar_get(object, copy_marker_id);
+    if (rb_obj_is_kind_of(marker, rb_cIO)) return object;
+
+    containers_check_guard_target(object);
+    rb_ivar_set(object, copy_marker_id, containers_new_copy_marker());
+    return object;
+}
+
+static VALUE
+containers_unshareable_prevent_movable(VALUE module, VALUE object)
+{
+    VALUE marker;
+    (void)module;
+
+    if (RB_SPECIAL_CONST_P(object)) {
+        rb_raise(rb_eTypeError, "cannot guard an immediate value");
+    }
+
+    if (containers_pin_marker_p(rb_ivar_get(object, pin_marker_id))) return object;
+    marker = rb_ivar_get(object, move_marker_id);
+    if (rb_obj_is_kind_of(marker, rb_cTime)) return object;
+
+    containers_check_guard_target(object);
+    rb_ivar_set(object, move_marker_id, rb_time_new(0, 0));
+    return object;
+}
+
+void
+containers_init_unshareable(VALUE namespace)
+{
+    VALUE module = rb_define_module_under(namespace, "Unshareable");
+
+    pin_marker_id = rb_intern("__ractor_containers_pin__");
+    copy_marker_id = rb_intern("__ractor_containers_prevent_copy__");
+    move_marker_id = rb_intern("__ractor_containers_prevent_move__");
+    pipe_id = rb_intern("pipe");
+    close_id = rb_intern("close");
+    eIsolationError = rb_const_get(rb_cRactor, rb_intern("IsolationError"));
+
+    cPinMarker = rb_class_new(rb_cObject);
+    rb_undef_alloc_func(cPinMarker);
+    rb_global_variable(&cPinMarker);
+
+    rb_define_singleton_method(module, "pin_to_current_ractor", containers_unshareable_pin, 1);
+    rb_define_singleton_method(module, "prevent_copyable", containers_unshareable_prevent_copyable, 1);
+    rb_define_singleton_method(module, "prevent_movable", containers_unshareable_prevent_movable, 1);
+}

data/ext/farce/unshared_io_pool.h

@@ -0,0 +1,234 @@
+#ifndef FARCE_UNSHARED_IO_POOL_H
+#define FARCE_UNSHARED_IO_POOL_H
+
+#include "unshared_wait.h"
+#include "ruby/io.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+/* Each pair belongs to its Ruby IO objects. Native code never closes their
+ * descriptors. A slot stays active until io_wait returns or unwinds, so no
+ * scheduler can observe a descriptor reassigned to another pending wait. */
+typedef struct farce_io_slot farce_io_slot_t;
+struct farce_io_slot {
+    VALUE reader;
+    VALUE writer;
+    int read_fd;
+    int write_fd;
+    bool notified;
+    bool broken;
+    farce_io_slot_t *all_previous;
+    farce_io_slot_t *all_next;
+    farce_io_slot_t *idle_next;
+    farce_io_slot_t *previous;
+    farce_io_slot_t *next;
+};
+
+typedef struct {
+    farce_io_slot_t *all;
+    farce_io_slot_t *idle;
+    farce_io_slot_t *active;
+    size_t idle_count;
+    size_t active_count;
+    size_t size;
+} farce_io_pool_t;
+
+#define FARCE_IO_POOL_IDLE_LIMIT 2
+
+static void
+farce_io_pool_mark(farce_io_pool_t *pool)
+{
+    for (farce_io_slot_t *slot = pool->all; slot; slot = slot->all_next) {
+        rb_gc_mark(slot->reader);
+        rb_gc_mark(slot->writer);
+    }
+}
+
+static void
+farce_io_pool_free(farce_io_pool_t *pool)
+{
+    farce_io_slot_t *slot = pool->all;
+    while (slot) {
+        farce_io_slot_t *next = slot->all_next;
+        /* Ruby finalizes the IO objects and their owned descriptors. */
+        free(slot);
+        slot = next;
+    }
+}
+
+static size_t
+farce_io_pool_memsize(farce_io_pool_t *pool)
+{
+    return pool->size * sizeof(farce_io_slot_t);
+}
+
+static VALUE
+farce_io_pool_descriptor(VALUE io)
+{
+    return INT2NUM(rb_io_descriptor(io));
+}
+
+static void
+farce_io_pool_discard(farce_io_pool_t *pool, farce_io_slot_t *slot)
+{
+    if (slot->all_previous) slot->all_previous->all_next = slot->all_next;
+    else pool->all = slot->all_next;
+    if (slot->all_next) slot->all_next->all_previous = slot->all_previous;
+    pool->size--;
+    VALUE reader = slot->reader;
+    VALUE writer = slot->writer;
+    free(slot);
+    /* Cleanup must close both ends without masking the original exception. */
+    VALUE error = rb_errinfo();
+    int state;
+    rb_protect(rb_io_close, reader, &state);
+    rb_set_errinfo(error);
+    rb_protect(rb_io_close, writer, &state);
+    rb_set_errinfo(error);
+    RB_GC_GUARD(reader);
+    RB_GC_GUARD(writer);
+    RB_GC_GUARD(error);
+}
+
+static farce_io_slot_t *
+farce_io_pool_acquire(farce_io_pool_t *pool)
+{
+    if (pool->idle) {
+        farce_io_slot_t *slot = pool->idle;
+        pool->idle = slot->idle_next;
+        pool->idle_count--;
+        slot->idle_next = NULL;
+        return slot;
+    }
+
+    /* IO.pipe supplies fully owned, exception-safe Ruby handles. If setup
+     * raises before the slot is linked, Ruby still owns both descriptors. */
+    VALUE pair = rb_funcall(rb_cIO, rb_intern("pipe"), 0);
+    VALUE reader = rb_ary_entry(pair, 0);
+    VALUE writer = rb_ary_entry(pair, 1);
+    int read_fd = rb_io_descriptor(reader);
+    int write_fd = rb_io_descriptor(writer);
+#ifndef _WIN32
+    int read_flags = fcntl(read_fd, F_GETFL, 0);
+    int write_flags = fcntl(write_fd, F_GETFL, 0);
+    if (read_flags < 0 || write_flags < 0 ||
+        fcntl(read_fd, F_SETFL, read_flags | O_NONBLOCK) < 0 ||
+        fcntl(write_fd, F_SETFL, write_flags | O_NONBLOCK) < 0) rb_sys_fail("fcntl");
+#endif
+    farce_io_slot_t *slot = calloc(1, sizeof(*slot));
+    if (!slot) rb_memerror();
+    slot->reader = reader;
+    slot->writer = writer;
+    slot->read_fd = read_fd;
+    slot->write_fd = write_fd;
+    slot->all_next = pool->all;
+    if (slot->all_next) slot->all_next->all_previous = slot;
+    pool->all = slot;
+    pool->size++;
+    RB_GC_GUARD(pair);
+    return slot;
+}
+
+static void
+farce_io_pool_release(farce_io_pool_t *pool, farce_io_slot_t *slot)
+{
+    VALUE error = rb_errinfo();
+    int state;
+    VALUE descriptor = rb_protect(farce_io_pool_descriptor, slot->reader, &state);
+    rb_set_errinfo(error);
+    if (state || NUM2INT(descriptor) != slot->read_fd) slot->broken = true;
+    if (!slot->broken && slot->notified) {
+        unsigned char byte;
+        ssize_t count;
+        do { count = read(slot->read_fd, &byte, 1); } while (count < 0 && errno == EINTR);
+        if (count == 0 || (count < 0 && errno != EAGAIN && errno != EWOULDBLOCK)) slot->broken = true;
+    }
+    slot->notified = false;
+    if (slot->broken || pool->idle_count == FARCE_IO_POOL_IDLE_LIMIT) {
+        farce_io_pool_discard(pool, slot);
+    }
+    else {
+        slot->idle_next = pool->idle;
+        pool->idle = slot;
+        pool->idle_count++;
+    }
+    RB_GC_GUARD(error);
+}
+
+static void
+farce_io_pool_notify(farce_io_pool_t *pool)
+{
+    const unsigned char byte = 1;
+    for (farce_io_slot_t *slot = pool->active; slot; slot = slot->next) {
+        if (slot->notified || slot->broken) continue;
+        ssize_t count;
+        do { count = write(slot->write_fd, &byte, 1); } while (count < 0 && errno == EINTR);
+        if (count == 1 || (count < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))) slot->notified = true;
+        else slot->broken = true;
+    }
+}
+
+typedef struct {
+    farce_io_pool_t *pool;
+    farce_io_slot_t *slot;
+    bool (*ready)(void *);
+    void *data;
+    bool finite;
+    double deadline;
+    bool registered;
+    bool completed;
+} farce_io_pool_wait_t;
+
+static VALUE
+farce_io_pool_wait_body(VALUE opaque)
+{
+    farce_io_pool_wait_t *wait = (farce_io_pool_wait_t *)opaque;
+    wait->slot = farce_io_pool_acquire(wait->pool);
+    /* Acquiring a new pipe may run Ruby. Recheck the caller's condition before
+     * registering under the GVL, including notifications during allocation. */
+    if (wait->ready(wait->data)) { wait->completed = true; return Qtrue; }
+    double remaining = wait->finite ? wait->deadline - farce_unshared_wait_now() : 0;
+    if (wait->finite && remaining <= 0) { wait->completed = true; return Qfalse; }
+    farce_io_slot_t *slot = wait->slot;
+    /* Older CRuby versions dispatch io_wait without checking a closed IO.
+     * Validate before handing a cached object back to the scheduler. */
+    if (rb_io_descriptor(slot->reader) != slot->read_fd) rb_raise(rb_eIOError, "queue wait descriptor changed");
+    slot->previous = NULL;
+    slot->next = wait->pool->active;
+    if (slot->next) slot->next->previous = slot;
+    wait->pool->active = slot;
+    wait->pool->active_count++;
+    wait->registered = true;
+    VALUE result = rb_io_wait(slot->reader, INT2NUM(RUBY_IO_READABLE), wait->finite ? DBL2NUM(remaining) : Qnil);
+    wait->completed = true;
+    return result;
+}
+
+static VALUE
+farce_io_pool_wait_cleanup(VALUE opaque)
+{
+    farce_io_pool_wait_t *wait = (farce_io_pool_wait_t *)opaque;
+    if (!wait->slot) return Qnil;
+    farce_io_slot_t *slot = wait->slot;
+    if (wait->registered) {
+        if (slot->previous) slot->previous->next = slot->next;
+        else wait->pool->active = slot->next;
+        if (slot->next) slot->next->previous = slot->previous;
+        wait->pool->active_count--;
+    }
+    /* An interrupted scheduler may have started closing its IO. Finish that
+     * close after rb_io_wait unwinds, and never reuse an exceptional slot. */
+    if (!wait->completed) slot->broken = true;
+    farce_io_pool_release(wait->pool, slot);
+    return Qnil;
+}
+
+static bool
+farce_io_pool_wait(farce_io_pool_t *pool, bool finite, double deadline, bool (*ready)(void *), void *data)
+{
+    farce_io_pool_wait_t wait = {.pool = pool, .finite = finite, .deadline = deadline, .ready = ready, .data = data};
+    return RTEST(rb_ensure(farce_io_pool_wait_body, (VALUE)&wait, farce_io_pool_wait_cleanup, (VALUE)&wait));
+}
+
+#endif

data/ext/farce/unshared_signal.c

@@ -0,0 +1,263 @@
+#include "unshared_io_pool.h"
+
+static VALUE cUnsharedSignal;
+static VALUE cUnsharedIOSignal;
+static VALUE cUnsharedBlockSignal;
+
+struct containers_unshared_signal {
+    farce_unshared_wait_list_t waiters;
+    uint64_t generation;
+    farce_io_pool_t fiber_pool;
+    size_t fiber_waiters;
+    bool initialized;
+    bool fiber_io;
+};
+
+static void
+unshared_signal_mark(void *pointer)
+{
+    containers_unshared_signal_t *signal = pointer;
+    farce_unshared_wait_mark(&signal->waiters);
+    farce_io_pool_mark(&signal->fiber_pool);
+}
+
+static void
+unshared_signal_free(void *pointer)
+{
+    containers_unshared_signal_t *signal = pointer;
+    farce_io_pool_free(&signal->fiber_pool);
+    ruby_xfree(signal);
+}
+
+static size_t
+unshared_signal_memsize(const void *pointer)
+{
+    const containers_unshared_signal_t *signal = pointer;
+    return signal ? sizeof(*signal) + signal->fiber_pool.size * sizeof(farce_io_slot_t) : 0;
+}
+
+static const rb_data_type_t unshared_signal_type = {
+    .wrap_struct_name = "Farce::Internal::UnsharedSignal",
+    .function = {
+        .dmark = unshared_signal_mark,
+        .dfree = unshared_signal_free,
+        .dsize = unshared_signal_memsize,
+    },
+};
+
+static VALUE
+unshared_signal_allocate_mode(VALUE klass, bool fiber_io)
+{
+    containers_unshared_signal_t *signal;
+    VALUE self = TypedData_Make_Struct(klass, containers_unshared_signal_t, &unshared_signal_type, signal);
+    signal->fiber_io = fiber_io;
+    return self;
+}
+
+static VALUE unshared_signal_allocate(VALUE klass) { return unshared_signal_allocate_mode(klass, FARCE_UNSHARED_FIBER_IO); }
+static VALUE unshared_io_signal_allocate(VALUE klass) { return unshared_signal_allocate_mode(klass, true); }
+static VALUE unshared_block_signal_allocate(VALUE klass) { return unshared_signal_allocate_mode(klass, false); }
+
+static containers_unshared_signal_t *
+unshared_signal_get(VALUE self)
+{
+    containers_unshared_signal_t *signal;
+    TypedData_Get_Struct(self, containers_unshared_signal_t, &unshared_signal_type, signal);
+    if (!signal->initialized) rb_raise(rb_eRuntimeError, "uninitialized Signal");
+    return signal;
+}
+
+/* Only the built-in classes bypass Ruby dispatch. Further subclasses retain
+ * ordinary protocol dispatch, including overrides. */
+containers_unshared_signal_t *
+containers_unshared_signal_get_if_exact(VALUE self)
+{
+    VALUE klass = CLASS_OF(self);
+    return klass == cUnsharedSignal || klass == cUnsharedIOSignal || klass == cUnsharedBlockSignal ?
+        unshared_signal_get(self) : NULL;
+}
+
+bool
+containers_unshared_fiber_io(VALUE mode)
+{
+    if (mode == Qundef || mode == ID2SYM(rb_intern("auto"))) return FARCE_UNSHARED_FIBER_IO;
+    if (mode == ID2SYM(rb_intern("io"))) return true;
+    if (mode == ID2SYM(rb_intern("block"))) return false;
+    rb_raise(rb_eArgError, "fiber_wait must be :auto, :io, or :block");
+}
+
+/* Comparison-lock contention follows even a user subclass's native waiting
+ * policy. Inspecting it here never calls Ruby during queue publication. */
+bool
+containers_unshared_signal_uses_fiber_io(VALUE self)
+{
+    if (!rb_typeddata_is_kind_of(self, &unshared_signal_type)) return FARCE_UNSHARED_FIBER_IO;
+    return unshared_signal_get(self)->fiber_io;
+}
+
+static VALUE
+unshared_signal_for(VALUE klass, VALUE mode)
+{
+    (void)klass;
+    bool fiber_io = containers_unshared_fiber_io(mode);
+    VALUE selected = mode == ID2SYM(rb_intern("auto")) ? cUnsharedSignal :
+        (fiber_io ? cUnsharedIOSignal : cUnsharedBlockSignal);
+    return rb_class_new_instance(0, NULL, selected);
+}
+
+static VALUE
+unshared_signal_fiber_wait(VALUE self)
+{
+    return ID2SYM(rb_intern(unshared_signal_get(self)->fiber_io ? "io" : "block"));
+}
+
+bool
+containers_unshared_signal_has_waiters(containers_unshared_signal_t *signal)
+{
+    return signal->waiters.count != 0 || signal->fiber_waiters != 0;
+}
+
+void
+containers_unshared_signal_notify(containers_unshared_signal_t *signal)
+{
+    signal->generation++;
+    /* Pipe notification does not call Ruby. Notify fibers before direct
+     * scheduler callbacks, which may yield or raise. */
+    if (signal->fiber_waiters) farce_io_pool_notify(&signal->fiber_pool);
+    farce_unshared_wait_notify_all(&signal->waiters);
+}
+
+static VALUE
+unshared_signal_initialize(VALUE self)
+{
+    containers_unshared_signal_t *signal;
+    TypedData_Get_Struct(self, containers_unshared_signal_t, &unshared_signal_type, signal);
+    if (signal->initialized) rb_raise(rb_eRuntimeError, "Signal is already initialized");
+    rb_check_frozen(self);
+    signal->initialized = true;
+    rb_obj_freeze(self);
+    return self;
+}
+
+static VALUE
+unshared_signal_initialize_copy(VALUE self, VALUE other)
+{
+    (void)self;
+    (void)other;
+    rb_raise(rb_eTypeError, "cannot copy Signal");
+}
+
+static VALUE
+unshared_signal_generation(VALUE self)
+{
+    return ULL2NUM(unshared_signal_get(self)->generation);
+}
+
+static VALUE
+unshared_signal_num_waiting(VALUE self)
+{
+    containers_unshared_signal_t *signal = unshared_signal_get(self);
+    return SIZET2NUM(signal->waiters.count + signal->fiber_waiters);
+}
+
+static VALUE
+unshared_signal_broadcast(VALUE self)
+{
+    containers_unshared_signal_t *signal = unshared_signal_get(self);
+    uint64_t generation = signal->generation + 1;
+    containers_unshared_signal_notify(signal);
+    return ULL2NUM(generation);
+}
+
+typedef struct {
+    containers_unshared_signal_t *signal;
+    uint64_t observed;
+    double deadline;
+    bool finite;
+} unshared_signal_fiber_wait_t;
+
+static bool
+unshared_signal_fiber_ready(void *opaque)
+{
+    unshared_signal_fiber_wait_t *wait = opaque;
+    return wait->signal->generation != wait->observed;
+}
+
+static VALUE
+unshared_signal_fiber_wait_body(VALUE opaque)
+{
+    unshared_signal_fiber_wait_t *wait = (unshared_signal_fiber_wait_t *)opaque;
+    return farce_io_pool_wait(&wait->signal->fiber_pool, wait->finite, wait->deadline,
+                              unshared_signal_fiber_ready, wait) ? Qtrue : Qfalse;
+}
+
+static VALUE
+unshared_signal_fiber_wait_cleanup(VALUE opaque)
+{
+    unshared_signal_fiber_wait_t *wait = (unshared_signal_fiber_wait_t *)opaque;
+    wait->signal->fiber_waiters--;
+    return Qnil;
+}
+
+static VALUE
+unshared_signal_wait(int argc, VALUE *argv, VALUE self)
+{
+    VALUE observed_value = Qnil;
+    VALUE keywords = Qnil;
+    VALUE keyword_values[1] = {Qundef};
+    ID keyword_ids[] = {rb_intern("timeout")};
+    rb_scan_args(argc, argv, "01:", &observed_value, &keywords);
+    if (!NIL_P(keywords)) rb_get_kwargs(keywords, keyword_ids, 0, 1, keyword_values);
+
+    bool snapshot_at_entry = NIL_P(observed_value);
+    uint64_t observed = snapshot_at_entry ? 0 : NUM2ULL(observed_value);
+    VALUE timeout = keyword_values[0] == Qundef ? Qnil : keyword_values[0];
+    bool finite = !NIL_P(timeout);
+    double deadline = 0;
+    if (finite) {
+        double seconds = NUM2DBL(timeout);
+        if (!isfinite(seconds) || seconds < 0) {
+            rb_raise(rb_eArgError, "timeout must be a finite, non-negative number or nil");
+        }
+        deadline = farce_unshared_wait_now() + seconds;
+    }
+    containers_unshared_signal_t *signal = unshared_signal_get(self);
+    if (snapshot_at_entry) observed = signal->generation;
+
+    /* Coercion above may run Ruby. The generation check and registration below
+     * run together under the GVL, so a broadcast cannot slip between them. */
+    while (signal->generation == observed) {
+        if (finite && farce_unshared_wait_now() >= deadline) {
+            return rb_block_given_p() ? rb_yield_values(0) : Qnil;
+        }
+        if (signal->fiber_io && !NIL_P(rb_fiber_scheduler_current())) {
+            /* Reuse owned pipe objects after each scheduler wait unwinds. */
+            unshared_signal_fiber_wait_t wait = {signal, observed, deadline, finite};
+            signal->fiber_waiters++;
+            rb_ensure(unshared_signal_fiber_wait_body, (VALUE)&wait,
+                      unshared_signal_fiber_wait_cleanup, (VALUE)&wait);
+        }
+        else farce_unshared_wait(&signal->waiters, self, finite, deadline);
+    }
+    return ULL2NUM(signal->generation);
+}
+
+void
+containers_init_unshared_signal(VALUE namespace)
+{
+    rb_define_const(namespace, "UNSHARED_FIBER_IO", FARCE_UNSHARED_FIBER_IO ? Qtrue : Qfalse);
+    cUnsharedSignal = rb_define_class_under(namespace, "UnsharedSignal", rb_cObject);
+    rb_define_alloc_func(cUnsharedSignal, unshared_signal_allocate);
+    cUnsharedIOSignal = rb_define_class_under(namespace, "UnsharedIOSignal", cUnsharedSignal);
+    rb_define_alloc_func(cUnsharedIOSignal, unshared_io_signal_allocate);
+    cUnsharedBlockSignal = rb_define_class_under(namespace, "UnsharedBlockSignal", cUnsharedSignal);
+    rb_define_alloc_func(cUnsharedBlockSignal, unshared_block_signal_allocate);
+    rb_define_singleton_method(cUnsharedSignal, "for", unshared_signal_for, 1);
+    rb_define_method(cUnsharedSignal, "fiber_wait", unshared_signal_fiber_wait, 0);
+    rb_define_private_method(cUnsharedSignal, "initialize", unshared_signal_initialize, 0);
+    rb_define_private_method(cUnsharedSignal, "initialize_copy", unshared_signal_initialize_copy, 1);
+    rb_define_method(cUnsharedSignal, "generation", unshared_signal_generation, 0);
+    rb_define_method(cUnsharedSignal, "num_waiting", unshared_signal_num_waiting, 0);
+    rb_define_method(cUnsharedSignal, "broadcast", unshared_signal_broadcast, 0);
+    rb_define_method(cUnsharedSignal, "wait", unshared_signal_wait, -1);
+}