farce 0.1.0-arm-linux-gnu → 0.2.0-arm-linux-gnu

data/ext/farce/unshareable.c

@@ -1,34 +1,69 @@
 #include "containers.h"
 
 typedef struct {
-    unsigned char reserved;
-} containers_pin_marker_t;
+    VALUE owner_class;
+} containers_marker_t;
 
 static ID pin_marker_id;
 static ID copy_marker_id;
 static ID move_marker_id;
+static ID share_marker_id;
+static ID owner_class_id;
+static ID new_id;
 static ID pipe_id;
 static ID close_id;
 static VALUE cPinMarker;
+static VALUE cNoncopyableMarker;
+static VALUE cNonmovableMarker;
+static VALUE cUnshareableMarker;
+static VALUE eRactorError;
 static VALUE eIsolationError;
 
+static void
+containers_marker_mark(void *pointer)
+{
+    containers_marker_t *marker = pointer;
+    rb_gc_mark_movable(marker->owner_class);
+}
+
+static void
+containers_marker_compact(void *pointer)
+{
+    containers_marker_t *marker = pointer;
+    containers_gc_update(&marker->owner_class);
+}
+
 static size_t
-containers_pin_marker_size(const void *pointer)
+containers_marker_size(const void *pointer)
 {
-    return pointer == NULL ? 0 : sizeof(containers_pin_marker_t);
+    return pointer == NULL ? 0 : sizeof(containers_marker_t);
 }
 
 static const rb_data_type_t containers_pin_marker_type = {
     .wrap_struct_name = "Ractor::Containers pin marker",
     .function = {
-        .dmark = NULL,
+        .dmark = containers_marker_mark,
         .dfree = RUBY_TYPED_DEFAULT_FREE,
-        .dsize = containers_pin_marker_size,
-        .dcompact = NULL,
+        .dsize = containers_marker_size,
+        .dcompact = containers_marker_compact,
     },
     .parent = NULL,
     .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY | FARCE_TYPED_THREAD_SAFE_FREE,
+};
+
+/* Native class metadata avoids the unshareable generic ivar storage of T_DATA. */
+static const rb_data_type_t containers_nonmovable_marker_type = {
+    .wrap_struct_name = "Farce nonmovable marker",
+    .function = {
+        .dmark = containers_marker_mark,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = containers_marker_size,
+        .dcompact = containers_marker_compact,
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY | FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static bool
@@ -51,30 +86,92 @@ containers_check_guard_target(VALUE object)
 }
 
 static VALUE
-containers_new_pin_marker(void)
+containers_marker_initialize(VALUE marker, VALUE owner_class)
+{
+    Check_Type(owner_class, T_CLASS);
+    rb_ivar_set(marker, owner_class_id, owner_class);
+    return marker;
+}
+
+static VALUE
+containers_marker_owner_class(VALUE marker)
+{
+    if (containers_pin_marker_p(marker) || rb_typeddata_is_kind_of(marker, &containers_nonmovable_marker_type)) {
+        return ((containers_marker_t *)RTYPEDDATA_DATA(marker))->owner_class;
+    }
+    return rb_ivar_get(marker, owner_class_id);
+}
+
+static VALUE
+containers_marker_inspect(VALUE marker)
 {
-    containers_pin_marker_t *marker_data;
+    return rb_sprintf("#<unshareable marker for %"PRIsVALUE">", containers_marker_owner_class(marker));
+}
+
+static VALUE
+containers_new_pin_marker(VALUE owner_class)
+{
+    containers_marker_t *marker_data;
     VALUE marker = TypedData_Make_Struct(
         cPinMarker,
-        containers_pin_marker_t,
+        containers_marker_t,
         &containers_pin_marker_type,
         marker_data
     );
-    marker_data->reserved = 0;
+    marker_data->owner_class = Qnil;
+    RB_OBJ_WRITE(marker, &marker_data->owner_class, owner_class);
     rb_obj_freeze(marker);
     return marker;
 }
 
 static VALUE
-containers_new_copy_marker(void)
+containers_marker_reject_freeze(VALUE marker)
+{
+    rb_raise(eRactorError, "%"PRIsVALUE" cannot be made Ractor-shareable", containers_marker_owner_class(marker));
+}
+
+static VALUE
+containers_noncopyable_marker_new(VALUE klass, VALUE owner_class)
 {
-    VALUE pair = rb_funcall(rb_cIO, pipe_id, 0);
+    VALUE pair = rb_funcall(klass, 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;
+    return containers_marker_initialize(reader, owner_class);
+}
+
+static VALUE
+containers_nonmovable_marker_allocate(VALUE klass)
+{
+    containers_marker_t *marker_data;
+    VALUE marker = TypedData_Make_Struct(
+        klass,
+        containers_marker_t,
+        &containers_nonmovable_marker_type,
+        marker_data
+    );
+    marker_data->owner_class = Qnil;
+    return marker;
+}
+
+static VALUE
+containers_nonmovable_marker_initialize(VALUE marker, VALUE owner_class)
+{
+    containers_marker_t *marker_data;
+    Check_Type(owner_class, T_CLASS);
+    TypedData_Get_Struct(marker, containers_marker_t, &containers_nonmovable_marker_type, marker_data);
+    RB_OBJ_WRITE(marker, &marker_data->owner_class, owner_class);
+    return marker;
+}
+
+static VALUE
+containers_nonmovable_marker_initialize_copy(VALUE marker, VALUE original)
+{
+    containers_marker_t *original_data;
+    TypedData_Get_Struct(original, containers_marker_t, &containers_nonmovable_marker_type, original_data);
+    return containers_nonmovable_marker_initialize(marker, original_data->owner_class);
 }
 
 static VALUE
@@ -91,7 +188,7 @@ containers_unshareable_pin(VALUE module, VALUE object)
     if (containers_pin_marker_p(marker)) return object;
 
     containers_check_guard_target(object);
-    rb_ivar_set(object, pin_marker_id, containers_new_pin_marker());
+    rb_ivar_set(object, pin_marker_id, containers_new_pin_marker(rb_obj_class(object)));
     return object;
 }
 
@@ -110,7 +207,7 @@ containers_unshareable_prevent_copyable(VALUE module, VALUE object)
     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());
+    rb_ivar_set(object, copy_marker_id, rb_funcall(cNoncopyableMarker, new_id, 1, rb_obj_class(object)));
     return object;
 }
 
@@ -126,10 +223,30 @@ containers_unshareable_prevent_movable(VALUE module, VALUE object)
 
     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;
+    if (rb_typeddata_is_kind_of(marker, &containers_nonmovable_marker_type)) return object;
 
     containers_check_guard_target(object);
-    rb_ivar_set(object, move_marker_id, rb_time_new(0, 0));
+    rb_ivar_set(object, move_marker_id, rb_funcall(cNonmovableMarker, new_id, 1, rb_obj_class(object)));
+    return object;
+}
+
+static VALUE
+containers_unshareable_prevent_shareable(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, share_marker_id);
+    if (rb_obj_is_kind_of(marker, cUnshareableMarker)) return object;
+
+    containers_check_guard_target(object);
+    VALUE owner_class = rb_obj_class(object);
+    rb_ivar_set(object, share_marker_id, rb_class_new_instance(1, &owner_class, cUnshareableMarker));
     return object;
 }
 
@@ -141,15 +258,47 @@ containers_init_unshareable(VALUE namespace)
     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__");
+    share_marker_id = rb_intern("__ractor_containers_prevent_share__");
+    owner_class_id = rb_intern("@owner_class");
+    new_id = rb_intern("new");
     pipe_id = rb_intern("pipe");
     close_id = rb_intern("close");
+    eRactorError = rb_const_get(rb_cRactor, rb_intern("Error"));
     eIsolationError = rb_const_get(rb_cRactor, rb_intern("IsolationError"));
 
     cPinMarker = rb_class_new(rb_cObject);
     rb_undef_alloc_func(cPinMarker);
+    rb_define_method(cPinMarker, "inspect", containers_marker_inspect, 0);
+    rb_define_method(cPinMarker, "to_s", containers_marker_inspect, 0);
     rb_global_variable(&cPinMarker);
 
+    /* Keep the native transfer restrictions while rejecting recursive freezing. */
+    cNoncopyableMarker = rb_define_class_under(module, "NoncopyableMarker", rb_cIO);
+    rb_define_singleton_method(cNoncopyableMarker, "new", containers_noncopyable_marker_new, 1);
+    rb_define_method(cNoncopyableMarker, "freeze", containers_marker_reject_freeze, 0);
+    rb_define_method(cNoncopyableMarker, "inspect", containers_marker_inspect, 0);
+    rb_define_method(cNoncopyableMarker, "to_s", containers_marker_inspect, 0);
+    cNonmovableMarker = rb_define_class_under(module, "NonmovableMarker", rb_cObject);
+    rb_define_alloc_func(cNonmovableMarker, containers_nonmovable_marker_allocate);
+    rb_define_method(cNonmovableMarker, "initialize", containers_nonmovable_marker_initialize, 1);
+    rb_define_method(cNonmovableMarker, "initialize_copy", containers_nonmovable_marker_initialize_copy, 1);
+    rb_define_method(cNonmovableMarker, "inspect", containers_marker_inspect, 0);
+    rb_define_method(cNonmovableMarker, "to_s", containers_marker_inspect, 0);
+    rb_define_method(cNonmovableMarker, "freeze", containers_marker_reject_freeze, 0);
+
+    /* Ruby 4.1's Ractor copier falls back to Marshal for extension data. */
+    rb_define_method(cNonmovableMarker, "marshal_dump", containers_marker_owner_class, 0);
+    rb_define_method(cNonmovableMarker, "marshal_load", containers_nonmovable_marker_initialize, 1);
+    cUnshareableMarker = rb_define_class_under(module, "UnshareableMarker", rb_cObject);
+    rb_define_method(cUnshareableMarker, "initialize", containers_marker_initialize, 1);
+    rb_define_method(cUnshareableMarker, "freeze", containers_marker_reject_freeze, 0);
+    rb_funcall(module, rb_intern("private_constant"), 3,
+               ID2SYM(rb_intern("NoncopyableMarker")),
+               ID2SYM(rb_intern("NonmovableMarker")),
+               ID2SYM(rb_intern("UnshareableMarker")));
+
     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);
+    rb_define_singleton_method(module, "prevent_shareable", containers_unshareable_prevent_shareable, 1);
 }

data/ext/farce/unshared_io_pool.h

@@ -40,8 +40,17 @@ 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);
+        rb_gc_mark_movable(slot->reader);
+        rb_gc_mark_movable(slot->writer);
+    }
+}
+
+static void
+farce_io_pool_compact(farce_io_pool_t *pool)
+{
+    for (farce_io_slot_t *slot = pool->all; slot; slot = slot->all_next) {
+        containers_gc_update(&slot->reader);
+        containers_gc_update(&slot->writer);
     }
 }
 
@@ -52,7 +61,7 @@ farce_io_pool_free(farce_io_pool_t *pool)
     while (slot) {
         farce_io_slot_t *next = slot->all_next;
         /* Ruby finalizes the IO objects and their owned descriptors. */
-        free(slot);
+        ruby_xfree(slot);
         slot = next;
     }
 }
@@ -78,7 +87,7 @@ farce_io_pool_discard(farce_io_pool_t *pool, farce_io_slot_t *slot)
     pool->size--;
     VALUE reader = slot->reader;
     VALUE writer = slot->writer;
-    free(slot);
+    ruby_xfree(slot);
     /* Cleanup must close both ends without masking the original exception. */
     VALUE error = rb_errinfo();
     int state;
@@ -92,7 +101,7 @@ farce_io_pool_discard(farce_io_pool_t *pool, farce_io_slot_t *slot)
 }
 
 static farce_io_slot_t *
-farce_io_pool_acquire(farce_io_pool_t *pool)
+farce_io_pool_acquire(VALUE self, farce_io_pool_t *pool)
 {
     if (pool->idle) {
         farce_io_slot_t *slot = pool->idle;
@@ -116,10 +125,9 @@ farce_io_pool_acquire(farce_io_pool_t *pool)
         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;
+    farce_io_slot_t *slot = ZALLOC(farce_io_slot_t);
+    RB_OBJ_WRITE(self, &slot->reader, reader);
+    RB_OBJ_WRITE(self, &slot->writer, writer);
     slot->read_fd = read_fd;
     slot->write_fd = write_fd;
     slot->all_next = pool->all;
@@ -170,6 +178,7 @@ farce_io_pool_notify(farce_io_pool_t *pool)
 }
 
 typedef struct {
+    VALUE self;
     farce_io_pool_t *pool;
     farce_io_slot_t *slot;
     bool (*ready)(void *);
@@ -184,7 +193,7 @@ 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);
+    wait->slot = farce_io_pool_acquire(wait->self, 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; }
@@ -225,9 +234,9 @@ farce_io_pool_wait_cleanup(VALUE opaque)
 }
 
 static bool
-farce_io_pool_wait(farce_io_pool_t *pool, bool finite, double deadline, bool (*ready)(void *), void *data)
+farce_io_pool_wait(VALUE self, 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};
+    farce_io_pool_wait_t wait = {.self = self, .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));
 }
 

data/ext/farce/unshared_signal.c

@@ -21,6 +21,14 @@ unshared_signal_mark(void *pointer)
     farce_io_pool_mark(&signal->fiber_pool);
 }
 
+/* Wait-list VALUEs are pinned by suspended C frames. Cached IOs can move. */
+static void
+unshared_signal_compact(void *pointer)
+{
+    containers_unshared_signal_t *signal = pointer;
+    farce_io_pool_compact(&signal->fiber_pool);
+}
+
 static void
 unshared_signal_free(void *pointer)
 {
@@ -42,7 +50,9 @@ static const rb_data_type_t unshared_signal_type = {
         .dmark = unshared_signal_mark,
         .dfree = unshared_signal_free,
         .dsize = unshared_signal_memsize,
+        .dcompact = unshared_signal_compact,
     },
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY | FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static VALUE
@@ -170,6 +180,7 @@ unshared_signal_broadcast(VALUE self)
 }
 
 typedef struct {
+    VALUE self;
     containers_unshared_signal_t *signal;
     uint64_t observed;
     double deadline;
@@ -187,7 +198,7 @@ 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,
+    return farce_io_pool_wait(wait->self, &wait->signal->fiber_pool, wait->finite, wait->deadline,
                               unshared_signal_fiber_ready, wait) ? Qtrue : Qfalse;
 }
 
@@ -232,7 +243,7 @@ unshared_signal_wait(int argc, VALUE *argv, VALUE self)
         }
         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};
+            unshared_signal_fiber_wait_t wait = {self, signal, observed, deadline, finite};
             signal->fiber_waiters++;
             rb_ensure(unshared_signal_fiber_wait_body, (VALUE)&wait,
                       unshared_signal_fiber_wait_cleanup, (VALUE)&wait);

data/ext/farce/unshared_wait.h

@@ -139,6 +139,9 @@ farce_unshared_wait(farce_unshared_wait_list_t *list, VALUE blocker, bool finite
         .linked = true,
         .notified = false,
     };
+    RB_OBJ_WRITTEN(blocker, Qundef, waiter.thread);
+    RB_OBJ_WRITTEN(blocker, Qundef, waiter.scheduler);
+    RB_OBJ_WRITTEN(blocker, Qundef, waiter.fiber);
     if (list->last) list->last->next = &waiter;
     else list->first = &waiter;
     list->last = &waiter;

data/ext/farce/vector.c

@@ -60,11 +60,11 @@ static void
 vector_compact(void *pointer)
 {
     vector_t *vector = pointer;
-    vector->updating_fiber = rb_gc_location(vector->updating_fiber);
-    vector->updating_thread = rb_gc_location(vector->updating_thread);
+    containers_gc_update(&vector->updating_fiber);
+    containers_gc_update(&vector->updating_thread);
     if (!vector->values) return;
     for (size_t index = 0; index < vector->size; index++) {
-        vector->values[index] = rb_gc_location(vector->values[index]);
+        containers_gc_update(&vector->values[index]);
     }
 }
 
@@ -92,7 +92,11 @@ static const rb_data_type_t vector_type = {
         .dsize = vector_memsize,
         .dcompact = vector_compact,
     },
-    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+    .flags =
+        RUBY_TYPED_WB_PROTECTED |
+        RUBY_TYPED_FROZEN_SHAREABLE |
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static void
@@ -133,6 +137,8 @@ get_vector(VALUE self)
     return vector;
 }
 
+/* Buffer growth also runs under the state mutex. Keep the allocator pair
+ * consistent and avoid Ruby allocators that can trigger GC in that section. */
 static VALUE *
 vector_allocate_values(size_t capacity)
 {
@@ -455,9 +461,9 @@ vector_initialize(int argc, VALUE *argv, VALUE self)
     vector->capacity = capacity;
 
     for (size_t index = 0; index < size; index++) {
-        VALUE value = RARRAY_AREF(source, (long)index);
+        VALUE value = rb_ary_entry(source, (long)index);
         containers_check_shareable(value);
-        vector->values[index] = value;
+        RB_OBJ_WRITE(self, &vector->values[index], value);
     }
     vector->size = size;
     vector->initialized = true;
@@ -604,7 +610,7 @@ vector_store_internal(VALUE self, vector_t *vector, long long raw, VALUE value,
         rb_memerror();
     }
     if (index >= vector->size) vector->size = index + 1;
-    vector->values[index] = value;
+    RB_OBJ_WRITE(self, &vector->values[index], value);
     vector_notify_waiters_locked(vector);
     pthread_mutex_unlock(&vector->lock);
     return value;
@@ -669,7 +675,7 @@ vector_push(int argc, VALUE *argv, VALUE self)
         pthread_mutex_unlock(&vector->lock);
         rb_memerror();
     }
-    vector->values[vector->size++] = value;
+    RB_OBJ_WRITE(self, &vector->values[vector->size++], value);
     vector_notify_waiters_locked(vector);
     pthread_mutex_unlock(&vector->lock);
     return self;
@@ -719,7 +725,7 @@ vector_swap(int argc, VALUE *argv, VALUE self)
     }
     VALUE previous = index < vector->size ? vector->values[index] : Qnil;
     if (index >= vector->size) vector->size = index + 1;
-    vector->values[index] = replacement;
+    RB_OBJ_WRITE(self, &vector->values[index], replacement);
     vector_notify_waiters_locked(vector);
     pthread_mutex_unlock(&vector->lock);
     return previous;
@@ -759,7 +765,7 @@ vector_store_if_absent_body(VALUE opaque)
     if (operation->index >= operation->vector->size) {
         operation->vector->size = operation->index + 1;
     }
-    operation->vector->values[operation->index] = result;
+    RB_OBJ_WRITE(operation->self, &operation->vector->values[operation->index], result);
     vector_finish_update_locked(operation->vector);
     pthread_mutex_unlock(&operation->vector->lock);
     operation->complete = true;
@@ -817,7 +823,7 @@ vector_cas_body(VALUE opaque)
     rb_check_frozen(operation->self);
 
     pthread_mutex_lock(&operation->vector->lock);
-    if (matches) operation->vector->values[operation->index] = operation->replacement;
+    if (matches) RB_OBJ_WRITE(operation->self, &operation->vector->values[operation->index], operation->replacement);
     vector_finish_update_locked(operation->vector);
     pthread_mutex_unlock(&operation->vector->lock);
     operation->complete = true;
@@ -869,7 +875,7 @@ vector_upsert_body(VALUE opaque)
     rb_check_frozen(operation->self);
     containers_check_shareable(result);
     pthread_mutex_lock(&operation->vector->lock);
-    operation->vector->values[operation->index] = result;
+    RB_OBJ_WRITE(operation->self, &operation->vector->values[operation->index], result);
     vector_finish_update_locked(operation->vector);
     pthread_mutex_unlock(&operation->vector->lock);
     operation->complete = true;
@@ -899,7 +905,7 @@ vector_upsert(int argc, VALUE *argv, VALUE self)
     }
     if (index >= vector->size) vector->size = index + 1;
     if (NIL_P(vector->values[index])) {
-        vector->values[index] = initial;
+        RB_OBJ_WRITE(self, &vector->values[index], initial);
         vector_notify_waiters_locked(vector);
         pthread_mutex_unlock(&vector->lock);
         return initial;
@@ -928,7 +934,7 @@ vector_update_body(VALUE opaque)
     if (operation->index >= operation->vector->size) {
         operation->vector->size = operation->index + 1;
     }
-    operation->vector->values[operation->index] = result;
+    RB_OBJ_WRITE(operation->self, &operation->vector->values[operation->index], result);
     vector_finish_update_locked(operation->vector);
     pthread_mutex_unlock(&operation->vector->lock);
     operation->complete = true;
@@ -967,6 +973,60 @@ vector_update(int argc, VALUE *argv, VALUE self)
     return rb_ensure(vector_update_body, (VALUE)&operation, vector_operation_cleanup, (VALUE)&operation);
 }
 
+static VALUE
+vector_batch_update_body(VALUE opaque)
+{
+    vector_operation_t *operation = (vector_operation_t *)opaque;
+    VALUE values = vector_snapshot(operation->self);
+    rb_yield(values);
+    rb_check_frozen(operation->self);
+    size_t size = (size_t)RARRAY_LEN(values);
+    for (size_t index = 0; index < size; index++) {
+        containers_check_shareable(rb_ary_entry(values, (long)index));
+    }
+    pthread_mutex_lock(&operation->vector->lock);
+    if (RB_OBJ_FROZEN(operation->self)) {
+        pthread_mutex_unlock(&operation->vector->lock);
+        rb_check_frozen(operation->self);
+    }
+    if (!vector_ensure_capacity(operation->vector, size)) {
+        pthread_mutex_unlock(&operation->vector->lock);
+        rb_memerror();
+    }
+    for (size_t index = 0; index < size; index++) {
+        RB_OBJ_WRITE(operation->self, &operation->vector->values[index], rb_ary_entry(values, (long)index));
+    }
+    for (size_t index = size; index < operation->vector->size; index++) {
+        operation->vector->values[index] = Qnil;
+    }
+    operation->vector->size = size;
+    vector_finish_update_locked(operation->vector);
+    pthread_mutex_unlock(&operation->vector->lock);
+    operation->complete = true;
+    RB_GC_GUARD(values);
+    return Qtrue;
+}
+
+static VALUE
+vector_batch_update(int argc, VALUE *argv, VALUE self)
+{
+    VALUE keywords = Qnil;
+    rb_scan_args(argc, argv, "0:", &keywords);
+    rb_check_frozen(self);
+    rb_need_block();
+    vector_timeout_t timeout = vector_parse_timeout(vector_timeout_keyword(keywords));
+    vector_t *vector = get_vector(self);
+    if (!vector_lock_for_update(vector, &timeout)) return Qfalse;
+    if (RB_OBJ_FROZEN(self)) {
+        pthread_mutex_unlock(&vector->lock);
+        rb_check_frozen(self);
+    }
+    vector_operation_t operation = { .self = self, .vector = vector, .complete = false };
+    vector->updating = true;
+    pthread_mutex_unlock(&vector->lock);
+    return rb_ensure(vector_batch_update_body, (VALUE)&operation, vector_operation_cleanup, (VALUE)&operation);
+}
+
 static bool
 vector_values_equal(vector_t *vector, VALUE left, VALUE right)
 {
@@ -1055,7 +1115,7 @@ unshared_vector_each(VALUE self)
     Check_Type(values, T_ARRAY);
     long limit = RARRAY_LEN(values);
     for (long index = 0; index < limit && index < RARRAY_LEN(values); index++) {
-        rb_yield(RARRAY_AREF(values, index));
+        rb_yield(rb_ary_entry(values, index));
     }
     RB_GC_GUARD(values);
     return self;
@@ -1071,7 +1131,7 @@ unshared_vector_reverse_each(VALUE self)
     while (index > 0) {
         if (index > RARRAY_LEN(values)) index = RARRAY_LEN(values);
         if (index == 0) break;
-        rb_yield(RARRAY_AREF(values, --index));
+        rb_yield(rb_ary_entry(values, --index));
     }
     RB_GC_GUARD(values);
     return self;
@@ -1097,6 +1157,9 @@ vector_transaction_apply(farce_transaction_entry_t *entry)
     copy->values = values;
     copy->capacity = capacity;
     copy->size = size;
+    for (size_t i = 0; i < vector->size; i++) {
+        RB_OBJ_WRITTEN(entry->source, Qundef, vector->values[i]);
+    }
 }
 
 static void
@@ -1110,8 +1173,8 @@ vector_transaction_reserve(farce_transaction_entry_t *entry, VALUE fiber, VALUE
 {
     vector_t *vector = entry->source_data;
     vector->updating = FARCE_TRANSACTION_RESERVED;
-    vector->updating_fiber = fiber;
-    vector->updating_thread = thread;
+    RB_OBJ_WRITE(entry->source, &vector->updating_fiber, fiber);
+    RB_OBJ_WRITE(entry->source, &vector->updating_thread, thread);
 }
 
 static void
@@ -1177,6 +1240,7 @@ containers_init_vector(VALUE namespace)
     rb_define_method(cVector, "reverse_each", vector_reverse_each, 0);
     rb_define_method(cVector, "fetch", vector_fetch, 1);
     rb_define_method(cVector, "clear", vector_clear, 0);
+    rb_define_method(cVector, "batch_update", vector_batch_update, -1);
     rb_define_method(cVector, "[]", vector_get_fast, 1);
     rb_define_method(cVector, "[]=", vector_set_fast, 2);
     rb_define_method(cVector, "get", vector_get, -1);