farce 0.1.0-aarch64-linux-gnu → 0.2.0-aarch64-linux-gnu

data/ext/farce/atom.c

@@ -44,6 +44,14 @@ typedef struct {
     bool initialized;
 } atom_t;
 
+/* Weak edges use the VM's separately registered weak-reference callback. */
+static inline void
+atom_write_value(VALUE self, atom_t *atom, VALUE value)
+{
+    if (atom->weak) atom->value = value;
+    else RB_OBJ_WRITE(self, &atom->value, value);
+}
+
 typedef struct {
     bool finite;
     bool collected;
@@ -158,9 +166,9 @@ static void
 atom_compact(void *pointer)
 {
     atom_t *atom = pointer;
-    atom->value = rb_gc_location(atom->value);
-    atom->updating_fiber = rb_gc_location(atom->updating_fiber);
-    atom->updating_thread = rb_gc_location(atom->updating_thread);
+    containers_gc_update(&atom->value);
+    containers_gc_update(&atom->updating_fiber);
+    containers_gc_update(&atom->updating_thread);
 }
 
 #ifdef RC_HAVE_NATIVE_WEAK_REFERENCES
@@ -203,7 +211,11 @@ static const rb_data_type_t atom_type = {
         .handle_weak_references = atom_handle_weak_references,
 #endif
     },
-    .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
@@ -228,6 +240,7 @@ static const rb_data_type_t unshared_weak_atom_type = {
         .handle_weak_references = atom_handle_weak_references,
     },
     .parent = &atom_type,
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY | FARCE_TYPED_THREAD_SAFE_FREE,
 };
 #endif
 
@@ -296,11 +309,11 @@ atom_check_update_wait_locked(atom_t *atom, const atom_execution_context_t *cont
 }
 
 static void
-atom_begin_update_locked(atom_t *atom, const atom_execution_context_t *context)
+atom_begin_update_locked(VALUE self, atom_t *atom, const atom_execution_context_t *context)
 {
     atom->updating = true;
-    atom->updating_fiber = context->fiber;
-    atom->updating_thread = context->thread;
+    RB_OBJ_WRITE(self, &atom->updating_fiber, context->fiber);
+    RB_OBJ_WRITE(self, &atom->updating_thread, context->thread);
 }
 
 static void
@@ -491,7 +504,7 @@ atom_initialize(int argc, VALUE *argv, VALUE self)
     TypedData_Get_Struct(self, atom_t, &atom_type, atom);
     if (atom->initialized) rb_raise(rb_eRuntimeError, "Atom is already initialized");
     atom_check_value(atom, value);
-    atom->value = value;
+    atom_write_value(self, atom, value);
     atom->compare_by_identity = identity == Qundef ? false : containers_strict_bool(identity, "compare_by_identity");
 #ifdef RC_HAVE_NATIVE_WEAK_REFERENCES
     if (atom->weak) rb_gc_declare_weak_references(self);
@@ -520,7 +533,7 @@ atom_set_value(VALUE self, VALUE value)
     atom_check_value(atom, value);
     atom_execution_context_t execution = atom_current_execution_context();
     atom_lock_for_update(atom, &execution);
-    atom->value = value;
+    atom_write_value(self, atom, value);
     atom_changed(atom);
     pthread_mutex_unlock(&atom->lock);
     return value;
@@ -560,7 +573,7 @@ atom_store(int argc, VALUE *argv, VALUE self)
     for (;;) {
         pthread_mutex_lock(&atom->lock);
         if (!atom->updating) {
-            atom->value = value;
+            atom_write_value(self, atom, value);
             atom_changed(atom);
             pthread_mutex_unlock(&atom->lock);
             return value;
@@ -586,7 +599,7 @@ atom_swap(int argc, VALUE *argv, VALUE self)
         pthread_mutex_lock(&atom->lock);
         if (!atom->updating) {
             VALUE previous = atom->value;
-            atom->value = value;
+            atom_write_value(self, atom, value);
             atom_changed(atom);
             pthread_mutex_unlock(&atom->lock);
             return previous;
@@ -626,7 +639,7 @@ atom_store_body(VALUE opaque)
     rb_check_frozen(operation->self);
     atom_check_value(operation->atom, result);
     pthread_mutex_lock(&operation->atom->lock);
-    operation->atom->value = result;
+    atom_write_value(operation->self, operation->atom, result);
     atom_finished_update(operation->atom, true);
     pthread_mutex_unlock(&operation->atom->lock);
     operation->complete = true;
@@ -654,7 +667,7 @@ atom_store_if_absent(int argc, VALUE *argv, VALUE self)
         pthread_mutex_unlock(&atom->lock);
         return value;
     }
-    atom_begin_update_locked(atom, &operation.execution);
+    atom_begin_update_locked(self, atom, &operation.execution);
     pthread_mutex_unlock(&atom->lock);
     return rb_ensure(atom_store_body, (VALUE)&operation, atom_operation_cleanup, (VALUE)&operation);
 }
@@ -692,7 +705,9 @@ atom_cas_body(VALUE opaque)
     rb_check_frozen(operation->self);
 
     pthread_mutex_lock(&operation->atom->lock);
-    if (matches) operation->atom->value = operation->replacement;
+    if (matches) {
+        atom_write_value(operation->self, operation->atom, operation->replacement);
+    }
     atom_finished_update(operation->atom, matches);
     pthread_mutex_unlock(&operation->atom->lock);
     operation->complete = true;
@@ -730,7 +745,7 @@ atom_compare_and_set(int argc, VALUE *argv, VALUE self)
     operation.replacement = replacement;
     operation.identity = atom->compare_by_identity;
     operation.complete = false;
-    atom_begin_update_locked(atom, &operation.execution);
+    atom_begin_update_locked(self, atom, &operation.execution);
     pthread_mutex_unlock(&atom->lock);
 
     return rb_ensure(atom_cas_body, (VALUE)&operation, atom_cas_cleanup, (VALUE)&operation);
@@ -744,7 +759,7 @@ atom_update_body(VALUE opaque)
     rb_check_frozen(operation->self);
     atom_check_value(operation->atom, result);
     pthread_mutex_lock(&operation->atom->lock);
-    operation->atom->value = result;
+    atom_write_value(operation->self, operation->atom, result);
     atom_finished_update(operation->atom, true);
     pthread_mutex_unlock(&operation->atom->lock);
     operation->complete = true;
@@ -768,7 +783,7 @@ atom_update(int argc, VALUE *argv, VALUE self)
 
     if (!atom_lock_for_update_with_timeout(atom, &timeout, &operation.execution)) return Qnil;
     operation.current = atom->value;
-    atom_begin_update_locked(atom, &operation.execution);
+    atom_begin_update_locked(self, atom, &operation.execution);
     pthread_mutex_unlock(&atom->lock);
 
     return rb_ensure(atom_update_body, (VALUE)&operation, atom_operation_cleanup, (VALUE)&operation);
@@ -793,13 +808,13 @@ atom_upsert(int argc, VALUE *argv, VALUE self)
 
     if (!atom_lock_for_update_with_timeout(atom, &timeout, &operation.execution)) return Qnil;
     if (NIL_P(atom->value)) {
-        atom->value = initial;
+        atom_write_value(self, atom, initial);
         atom_changed(atom);
         pthread_mutex_unlock(&atom->lock);
         return initial;
     }
     operation.current = atom->value;
-    atom_begin_update_locked(atom, &operation.execution);
+    atom_begin_update_locked(self, atom, &operation.execution);
     pthread_mutex_unlock(&atom->lock);
 
     return rb_ensure(atom_update_body, (VALUE)&operation, atom_operation_cleanup, (VALUE)&operation);
@@ -927,7 +942,7 @@ atom_transaction_apply(farce_transaction_entry_t *entry)
 {
     atom_t *atom = entry->source_data;
     atom_t *working = entry->working_data;
-    atom->value = working->value;
+    RB_OBJ_WRITE(entry->source, &atom->value, working->value);
 }
 
 static void
@@ -941,8 +956,8 @@ atom_transaction_reserve(farce_transaction_entry_t *entry, VALUE fiber, VALUE th
 {
     atom_t *atom = entry->source_data;
     atom->updating = FARCE_TRANSACTION_RESERVED;
-    atom->updating_fiber = fiber;
-    atom->updating_thread = thread;
+    RB_OBJ_WRITE(entry->source, &atom->updating_fiber, fiber);
+    RB_OBJ_WRITE(entry->source, &atom->updating_thread, thread);
 }
 
 static void

data/ext/farce/bounded_map.c

@@ -153,17 +153,17 @@ lru_compact(void *opaque)
     lru_map_t *map = opaque;
     if (map == NULL) return;
 
-    map->lock = rb_gc_location(map->lock);
+    containers_gc_update(&map->lock);
     if (map->lfu_policy) {
         for (lfu_bucket_t *bucket = map->least_frequency;
              bucket != NULL;
              bucket = bucket->following) {
-            bucket->frequency = rb_gc_location(bucket->frequency);
+            containers_gc_update(&bucket->frequency);
             for (lru_entry_t *entry = bucket->least_recent;
                  entry != NULL;
                  entry = entry->following) {
-                entry->key = rb_gc_location(entry->key);
-                entry->value = rb_gc_location(entry->value);
+                containers_gc_update(&entry->key);
+                containers_gc_update(&entry->value);
             }
         }
     }
@@ -171,8 +171,8 @@ lru_compact(void *opaque)
         for (lru_entry_t *entry = map->least_recent;
              entry != NULL;
              entry = entry->following) {
-            entry->key = rb_gc_location(entry->key);
-            entry->value = rb_gc_location(entry->value);
+            containers_gc_update(&entry->key);
+            containers_gc_update(&entry->value);
         }
     }
 }
@@ -207,7 +207,7 @@ static const rb_data_type_t lru_map_type = {
         .dsize = lru_memsize,
         .dcompact = lru_compact,
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY | FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static const rb_data_type_t lru_shared_map_type = {
@@ -218,7 +218,11 @@ static const rb_data_type_t lru_shared_map_type = {
         .dsize = lru_memsize,
         .dcompact = lru_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 VALUE
@@ -1320,8 +1324,8 @@ lru_each(VALUE self)
 
     for (long index = 0; index < length; index += 2) {
         rb_yield(rb_assoc_new(
-            RARRAY_AREF(entries, index),
-            RARRAY_AREF(entries, index + 1)
+            rb_ary_entry(entries, index),
+            rb_ary_entry(entries, index + 1)
         ));
     }
     RB_GC_GUARD(entries);
@@ -1338,7 +1342,7 @@ lru_each_key(VALUE self)
     long length = RARRAY_LEN(entries);
 
     for (long index = 0; index < length; index += 2) {
-        rb_yield(RARRAY_AREF(entries, index));
+        rb_yield(rb_ary_entry(entries, index));
     }
     RB_GC_GUARD(entries);
     return self;
@@ -1354,7 +1358,7 @@ lru_each_value(VALUE self)
     long length = RARRAY_LEN(entries);
 
     for (long index = 1; index < length; index += 2) {
-        rb_yield(RARRAY_AREF(entries, index));
+        rb_yield(rb_ary_entry(entries, index));
     }
     RB_GC_GUARD(entries);
     return self;
@@ -1370,7 +1374,7 @@ lru_keys(VALUE self)
     VALUE keys = rb_ary_new_capa(length / 2);
 
     for (long index = 0; index < length; index += 2) {
-        rb_ary_push(keys, RARRAY_AREF(entries, index));
+        rb_ary_push(keys, rb_ary_entry(entries, index));
     }
     RB_GC_GUARD(entries);
     rb_obj_freeze(keys);

data/ext/farce/containers.h

@@ -12,6 +12,21 @@
 #include <sys/time.h>
 #endif
 
+/* Ruby 4.1 can sweep independently owned native payloads in parallel. */
+#ifdef RUBY_TYPED_THREAD_SAFE_FREE
+# define FARCE_TYPED_THREAD_SAFE_FREE RUBY_TYPED_THREAD_SAFE_FREE
+#else
+# define FARCE_TYPED_THREAD_SAFE_FREE 0
+#endif
+
+/* Avoid dirtying a native page when compaction left the reference in place. */
+static inline void
+containers_gc_update(VALUE *reference)
+{
+    VALUE relocated = rb_gc_location(*reference);
+    if (relocated != *reference) *reference = relocated;
+}
+
 /* Use only after validating self as native TypedData. */
 static inline void
 containers_check_typed_frozen(VALUE self)

data/ext/farce/counter.c

@@ -49,29 +49,24 @@ counter_memsize(const void *pointer)
     return pointer ? sizeof(counter_t) : 0;
 }
 
-static void
-counter_mark(void *pointer)
-{
-    counter_t *counter = pointer;
-    rb_gc_mark_movable(counter->signal);
-}
-
-static void
-counter_compact(void *pointer)
-{
-    counter_t *counter = pointer;
-    counter->signal = rb_gc_location(counter->signal);
-}
+RUBY_REFERENCES(counter_references) = {
+    RUBY_REF_EDGE(counter_t, signal),
+    RUBY_REF_END,
+};
 
 static const rb_data_type_t counter_type = {
     .wrap_struct_name = "Ractor::Containers::Counter",
     .function = {
-        .dmark = counter_mark,
-        .dcompact = counter_compact,
+        .dmark = RUBY_REFS_LIST_PTR(counter_references),
         .dfree = counter_free,
         .dsize = counter_memsize,
     },
-    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+    .flags =
+        RUBY_TYPED_DECL_MARKING |
+        RUBY_TYPED_WB_PROTECTED |
+        RUBY_TYPED_FROZEN_SHAREABLE |
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static VALUE
@@ -136,7 +131,7 @@ counter_initialize(int argc, VALUE *argv, VALUE self)
 #else
     counter->value = value;
 #endif
-    counter->signal = containers_signal_new();
+    RB_OBJ_WRITE(self, &counter->signal, containers_signal_new());
     counter->initial = value;
     counter->initialized = true;
     return containers_publish_native_with_references(self, counter_validate_references);
@@ -183,7 +178,7 @@ counter_initialize_copy(VALUE self, VALUE other)
 #else
     copy->value = value;
 #endif
-    copy->signal = containers_signal_new();
+    RB_OBJ_WRITE(self, &copy->signal, containers_signal_new());
     copy->initial = source->initial;
     copy->initialized = true;
     return containers_publish_native_with_references(self, counter_validate_references);

data/ext/farce/exchanger.c

@@ -147,7 +147,11 @@ static const rb_data_type_t exchanger_type = {
         .dsize = exchanger_memsize,
         .dcompact = NULL,
     },
-    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+    .flags =
+        RUBY_TYPED_WB_PROTECTED |
+        RUBY_TYPED_FROZEN_SHAREABLE |
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static VALUE

data/ext/farce/farce.c

@@ -107,7 +107,7 @@ containers_normalize_string_key(VALUE key)
         long index;
 
         for (index = 0; index < RARRAY_LEN(instance_variables); index++) {
-            ID id = SYM2ID(RARRAY_AREF(instance_variables, index));
+            ID id = SYM2ID(rb_ary_entry(instance_variables, index));
             rb_ivar_set(stored_key, id, rb_ivar_get(key, id));
         }
         RB_GC_GUARD(instance_variables);

data/ext/farce/flag.c

@@ -18,6 +18,7 @@ typedef struct {
     pthread_mutex_t lock;
     bool value;
 #endif
+    VALUE signal;
     bool initialized;
 } flag_t;
 
@@ -42,13 +43,24 @@ flag_memsize(const void *pointer)
     return pointer ? sizeof(flag_t) : 0;
 }
 
+RUBY_REFERENCES(flag_references) = {
+    RUBY_REF_EDGE(flag_t, signal),
+    RUBY_REF_END,
+};
+
 static const rb_data_type_t flag_type = {
     .wrap_struct_name = "Ractor::Containers::Flag",
     .function = {
+        .dmark = RUBY_REFS_LIST_PTR(flag_references),
         .dfree = flag_free,
         .dsize = flag_memsize,
     },
-    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+    .flags =
+        RUBY_TYPED_DECL_MARKING |
+        RUBY_TYPED_WB_PROTECTED |
+        RUBY_TYPED_FROZEN_SHAREABLE |
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static VALUE
@@ -77,10 +89,23 @@ flag_allocate(VALUE klass)
     pthread_mutex_init(&flag->lock, NULL);
     flag->value = false;
 #endif
+    flag->signal = Qnil;
     flag->initialized = false;
     return object;
 }
 
+static void
+flag_validate_references(VALUE self)
+{
+    containers_check_shareable(get_flag(self)->signal);
+}
+
+static VALUE
+flag_change_signal(VALUE self)
+{
+    return get_flag(self)->signal;
+}
+
 static VALUE
 flag_initialize(int argc, VALUE *argv, VALUE self)
 {
@@ -99,8 +124,9 @@ flag_initialize(int argc, VALUE *argv, VALUE self)
 #else
     flag->value = value;
 #endif
+    RB_OBJ_WRITE(self, &flag->signal, containers_signal_new());
     flag->initialized = true;
-    return containers_publish_native_reference_free(self);
+    return containers_publish_native_with_references(self, flag_validate_references);
 }
 
 static VALUE
@@ -131,8 +157,9 @@ flag_initialize_copy(VALUE self, VALUE other)
 #else
     copy->value = value;
 #endif
+    RB_OBJ_WRITE(self, &copy->signal, containers_signal_new());
     copy->initialized = true;
-    return containers_publish_native_reference_free(self);
+    return containers_publish_native_with_references(self, flag_validate_references);
 }
 
 static VALUE
@@ -147,6 +174,7 @@ flag_set(VALUE self)
     flag->value = true;
     pthread_mutex_unlock(&flag->lock);
 #endif
+    containers_signal_broadcast(flag->signal);
     return Qtrue;
 }
 
@@ -162,6 +190,7 @@ flag_unset(VALUE self)
     flag->value = false;
     pthread_mutex_unlock(&flag->lock);
 #endif
+    containers_signal_broadcast(flag->signal);
     return Qfalse;
 }
 
@@ -178,6 +207,7 @@ flag_store(VALUE self, VALUE input)
     flag->value = value;
     pthread_mutex_unlock(&flag->lock);
 #endif
+    containers_signal_broadcast(flag->signal);
     return input;
 }
 
@@ -199,6 +229,7 @@ flag_swap(VALUE self, VALUE input)
     flag->value = replacement;
     pthread_mutex_unlock(&flag->lock);
 #endif
+    containers_signal_broadcast(flag->signal);
     return flag_boolean(previous);
 }
 
@@ -223,6 +254,7 @@ flag_compare_and_set(VALUE self, VALUE expected_input, VALUE replacement_input)
     if (exchanged) flag->value = replacement;
     pthread_mutex_unlock(&flag->lock);
 #endif
+    if (exchanged) containers_signal_broadcast(flag->signal);
     return flag_boolean(exchanged);
 }
 
@@ -243,6 +275,7 @@ flag_toggle(VALUE self)
                 memory_order_relaxed,
                 memory_order_relaxed
             )) {
+            containers_signal_broadcast(flag->signal);
             return flag_boolean(replacement);
         }
     }
@@ -250,6 +283,7 @@ flag_toggle(VALUE self)
     pthread_mutex_lock(&flag->lock);
     bool value = flag->value = !flag->value;
     pthread_mutex_unlock(&flag->lock);
+    containers_signal_broadcast(flag->signal);
     return flag_boolean(value);
 #endif
 }
@@ -261,6 +295,8 @@ containers_init_flag(VALUE namespace)
     rb_define_alloc_func(cFlag, flag_allocate);
     rb_define_method(cFlag, "initialize", flag_initialize, -1);
     rb_define_private_method(cFlag, "initialize_copy", flag_initialize_copy, 1);
+    rb_include_module(cFlag, rb_const_get(namespace, rb_intern("FlagWaiting")));
+    rb_define_method(cFlag, "change_signal", flag_change_signal, 0);
     rb_define_method(cFlag, "value", flag_value, 0);
     rb_define_alias(cFlag, "get", "value");
     rb_define_method(cFlag, "set", flag_set, 0);

data/ext/farce/io.c

@@ -21,7 +21,7 @@ static VALUE wait_cleanup(VALUE data) {
 static VALUE wait_body(VALUE data) {
     VALUE *args = (VALUE *)data;
     fs_state *s = fs_get(args[0]); fs_wait *w = fs_lookup(s, args[1]);
-    w->ios = args[2]; // GC root for the watched IO
+    RB_OBJ_WRITE(args[0], &w->ios, args[2]); // GC root for the watched IO
     fs_watch_io(s, w, rb_io_descriptor(args[2]), NUM2INT(args[3]), -1, 0);
     if (NIL_P(args[4])) return fs_suspend(args[0], args[1]);
     return rb_funcall(args[0], rb_intern("wait_with_timeout"), 3, args[1], args[4], INT2NUM(0));
@@ -82,7 +82,7 @@ static void transfer_wait(transfer *t, int events) {
     t->token = fs_arm_checked(t->self);
     fs_state *s = fs_get(t->self);
     fs_wait *w = fs_lookup(s, t->token);
-    w->ios = t->io;
+    RB_OBJ_WRITE(t->self, &w->ios, t->io);
     fs_watch_io(s, w, rb_io_descriptor(t->io), events, -1, 0);
     fs_suspend(t->self, t->token);
     fs_retire(t->self, t->token);
@@ -95,7 +95,7 @@ static ssize_t transfer_receive(transfer *t, void *buffer, size_t capacity) {
     t->token = fs_arm_checked(t->self);
     fs_state *s = fs_get(t->self);
     fs_wait *w = fs_lookup(s, t->token);
-    w->ios = t->io;
+    RB_OBJ_WRITE(t->self, &w->ios, t->io);
     int error = fs_driver_receive(s, w, rb_io_descriptor(t->io), buffer, capacity);
     if (error) rb_syserr_fail(error, "scheduler receive submission");
     VALUE result = fs_suspend(t->self, t->token);

data/ext/farce/lock.c

@@ -83,22 +83,6 @@ containers_lock_notify_one_locked(containers_lock_t *lock)
     }
 }
 
-static void
-containers_lock_mark(void *pointer)
-{
-    containers_lock_t *lock = pointer;
-    rb_gc_mark_movable(lock->owner);
-    rb_gc_mark_movable(lock->owner_thread);
-}
-
-static void
-containers_lock_compact(void *pointer)
-{
-    containers_lock_t *lock = pointer;
-    lock->owner = rb_gc_location(lock->owner);
-    lock->owner_thread = rb_gc_location(lock->owner_thread);
-}
-
 static void
 containers_lock_free(void *pointer)
 {
@@ -113,15 +97,25 @@ containers_lock_memsize(const void *pointer)
     return pointer ? sizeof(containers_lock_t) : 0;
 }
 
+RUBY_REFERENCES(containers_lock_references) = {
+    RUBY_REF_EDGE(containers_lock_t, owner),
+    RUBY_REF_EDGE(containers_lock_t, owner_thread),
+    RUBY_REF_END,
+};
+
 static const rb_data_type_t containers_lock_type = {
     .wrap_struct_name = "Ractor::Containers::Lock",
     .function = {
-        .dmark = containers_lock_mark,
+        .dmark = RUBY_REFS_LIST_PTR(containers_lock_references),
         .dfree = containers_lock_free,
         .dsize = containers_lock_memsize,
-        .dcompact = containers_lock_compact,
     },
-    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+    .flags =
+        RUBY_TYPED_DECL_MARKING |
+        RUBY_TYPED_WB_PROTECTED |
+        RUBY_TYPED_FROZEN_SHAREABLE |
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static VALUE
@@ -285,8 +279,8 @@ containers_lock_acquire(VALUE self)
             rb_raise(rb_eThreadError, "deadlock; recursive locking");
         }
         if (NIL_P(lock->owner)) {
-            lock->owner = current;
-            lock->owner_thread = current_thread;
+            RB_OBJ_WRITE(self, &lock->owner, current);
+            RB_OBJ_WRITE(self, &lock->owner_thread, current_thread);
             pthread_mutex_unlock(&lock->guard);
             return;
         }
@@ -338,8 +332,8 @@ containers_lock_try_lock(VALUE self)
 
     pthread_mutex_lock(&lock->guard);
     if (NIL_P(lock->owner)) {
-        lock->owner = current;
-        lock->owner_thread = rb_thread_current();
+        RB_OBJ_WRITE(self, &lock->owner, current);
+        RB_OBJ_WRITE(self, &lock->owner_thread, rb_thread_current());
         acquired = true;
     }
     pthread_mutex_unlock(&lock->guard);