farce 0.4.0-x86_64-linux-gnu → 0.5.0-x86_64-linux-gnu

data/ext/farce/tree_map.c

@@ -1,4 +1,5 @@
 #include "containers.h"
+#include "native_wait.h"
 #include "transaction.h"
 #include <ruby/atomic.h>
 #include <ruby/fiber/scheduler.h>
@@ -558,9 +559,7 @@ tc_map_store_unlocked(VALUE self, tc_map *map, VALUE key, VALUE value,
 typedef struct tc_core_map_waiter tc_core_map_waiter;
 
 struct tc_core_map_waiter {
-    int read_fd;
-    int write_fd;
-    bool notified;
+    containers_waiter_t notification;
     tc_core_map_waiter *next;
 };
 
@@ -787,40 +786,14 @@ typedef struct {
     tc_core_map_waiter waiter;
 } tc_core_map_fiber_wait;
 
-static void
-tc_core_map_set_fd_flags(int fd)
-{
-#ifdef _WIN32
-    (void)fd;
-#else
-    int flags = fcntl(fd, F_GETFL, 0);
-    if (flags >= 0) (void)fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-    flags = fcntl(fd, F_GETFD, 0);
-    if (flags >= 0) (void)fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
-#endif
-}
-
 /* Called with core->lock held. The waiter remains linked until its ensure
  * cleanup so an interrupt cannot leave a dangling stack pointer behind. */
 static void
 tc_core_map_notify_one_locked(tc_core_map *core)
 {
-    unsigned char byte = 1;
-
-    for (tc_core_map_waiter *waiter = core->waiters;
-         waiter != NULL;
-         waiter = waiter->next) {
-        ssize_t result;
-
-        if (waiter->notified) continue;
-        do {
-            result = write(waiter->write_fd, &byte, 1);
-        } while (result < 0 && errno == EINTR);
-        if (result == 1 ||
-            (result < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))) {
-            waiter->notified = true;
-            return;
-        }
+    for (tc_core_map_waiter *waiter = core->waiters; waiter; waiter = waiter->next) {
+        if (waiter->notification.notified) continue;
+        if (containers_waiter_notify(&waiter->notification)) return;
     }
 }
 
@@ -828,7 +801,9 @@ static VALUE
 tc_core_map_fiber_wait_body(VALUE opaque)
 {
     tc_core_map_fiber_wait *wait = (tc_core_map_fiber_wait *)opaque;
-    return containers_wait_for_readable(wait->waiter.read_fd, Qnil) ? Qtrue : Qfalse;
+    return containers_waiter_wait(
+        &wait->waiter.notification, &wait->core->lock, false, 0, NULL
+    ) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -851,9 +826,9 @@ tc_core_map_fiber_wait_cleanup(VALUE opaque)
     }
     /* Notification makes a waiter runnable, but does not reserve ownership.
      * Always pass the baton if a notified waiter leaves while ownerless,
-     * including cancellation after rb_io_wait returned but before the lock
+     * including cancellation after a wait returned but before the lock
      * acquisition loop claimed ownership. */
-    if (wait->waiter.notified &&
+    if (wait->waiter.notification.notified &&
         NIL_P(wait->core->owner_fiber) &&
         !tc_core_map_publication_busy(
             RUBY_ATOMIC_LOAD(wait->core->publication_state)
@@ -862,8 +837,7 @@ tc_core_map_fiber_wait_cleanup(VALUE opaque)
     }
     pthread_mutex_unlock(&wait->core->lock);
 
-    close(wait->waiter.read_fd);
-    close(wait->waiter.write_fd);
+    containers_waiter_close(&wait->waiter.notification);
     return Qnil;
 }
 
@@ -871,24 +845,11 @@ tc_core_map_fiber_wait_cleanup(VALUE opaque)
 static void
 tc_core_map_wait_once(tc_core_map *core)
 {
-    int descriptors[2];
-
-    if (pipe(descriptors) != 0) {
-        pthread_mutex_unlock(&core->lock);
-        rb_sys_fail("pipe");
-    }
-    tc_core_map_set_fd_flags(descriptors[0]);
-    tc_core_map_set_fd_flags(descriptors[1]);
-
     tc_core_map_fiber_wait wait = {
         .core = core,
-        .waiter = {
-            .read_fd = descriptors[0],
-            .write_fd = descriptors[1],
-            .notified = false,
-            .next = NULL,
-        },
+        .waiter = {.next = NULL},
     };
+    containers_waiter_init(&wait.waiter.notification);
 
     if (core->last_waiter != NULL) core->last_waiter->next = &wait.waiter;
     else core->waiters = &wait.waiter;
@@ -904,8 +865,8 @@ tc_core_map_wait_once(tc_core_map *core)
 }
 
 /* CRuby needs logical Fiber ownership rather than pthread ownership: multiple
- * scheduled Fibers can contend on the same native thread. Descriptor waits
- * let rb_io_wait park only the current Fiber while its owner resumes. */
+ * scheduled Fibers can contend on the same native thread. Native notifications
+ * park only the current Fiber while its owner resumes. */
 static void
 tc_core_map_lock(VALUE self, tc_core_map *core)
 {

data/ext/farce/unshareable.c

@@ -40,7 +40,7 @@ containers_marker_size(const void *pointer)
 }
 
 static const rb_data_type_t containers_pin_marker_type = {
-    .wrap_struct_name = "Ractor::Containers pin marker",
+    .wrap_struct_name = "Farce pin marker",
     .function = {
         .dmark = containers_marker_mark,
         .dfree = RUBY_TYPED_DEFAULT_FREE,

data/ext/farce/unsupported.c

@@ -1,6 +1,18 @@
-#include "ruby.h"
+#include "futex.h"
 
 void farce_init_fiber_scheduler(VALUE internal) {
     (void)internal;
     rb_raise(rb_eLoadError, "native Farce fiber scheduling requires epoll or kqueue; use the select implementation");
 }
+
+bool containers_futex_scheduler_supported(VALUE scheduler) {
+    (void)scheduler;
+    return false;
+}
+
+bool containers_futex_scheduler_wait(VALUE scheduler, containers_futex_t *word, VALUE timeout) {
+    (void)scheduler;
+    (void)word;
+    (void)timeout;
+    return true;
+}

data/ext/farce/vector.c

@@ -1,15 +1,13 @@
 #include "containers.h"
+#include "native_wait.h"
 #include "transaction.h"
-#include "ruby/io.h"
 #include "ruby/fiber/scheduler.h"
 
 #include <errno.h>
-#include <fcntl.h>
 #include <math.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <time.h>
-#include <unistd.h>
 
 #define VECTOR_INITIAL_CAPACITY 16
 static VALUE cVector;
@@ -19,9 +17,7 @@ static VALUE vector_transaction_marker;
 typedef struct vector_waiter vector_waiter_t;
 
 struct vector_waiter {
-    int read_fd;
-    int write_fd;
-    bool notified;
+    containers_waiter_t notification;
     vector_waiter_t *next;
 };
 
@@ -85,7 +81,7 @@ vector_memsize(const void *pointer)
 }
 
 static const rb_data_type_t vector_type = {
-    .wrap_struct_name = "Ractor::Containers::Vector",
+    .wrap_struct_name = "Farce::Internal::Vector",
     .function = {
         .dmark = vector_mark,
         .dfree = vector_free,
@@ -214,35 +210,14 @@ vector_timeout_keyword(VALUE keywords)
     return timeout;
 }
 
-static void
-vector_set_fd_flags(int fd)
-{
-#ifdef _WIN32
-    (void)fd;
-#else
-    int flags = fcntl(fd, F_GETFL, 0);
-    if (flags >= 0) (void)fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-    flags = fcntl(fd, F_GETFD, 0);
-    if (flags >= 0) (void)fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
-#endif
-}
-
-/* Called with vector->lock held. Each waiter has an independent pipe, so a
- * transition wakes every waiting thread or scheduled fiber. */
+/* Called with vector->lock held. A transition wakes every registered
+ * thread or fiber without sharing a consumable notification. */
 static void
 vector_notify_waiters_locked(vector_t *vector)
 {
-    unsigned char byte = 1;
     vector->generation++;
     for (vector_waiter_t *waiter = vector->waiters; waiter; waiter = waiter->next) {
-        if (waiter->notified) continue;
-        ssize_t result;
-        do {
-            result = write(waiter->write_fd, &byte, 1);
-        } while (result < 0 && errno == EINTR);
-        if (result == 1 || (result < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))) {
-            waiter->notified = true;
-        }
+        (void)containers_waiter_notify(&waiter->notification);
     }
 }
 
@@ -259,23 +234,14 @@ typedef struct {
     vector_timeout_t *timeout;
 } vector_wait_context_t;
 
-static bool
-vector_wait_for_descriptor(int fd, vector_timeout_t *timeout)
-{
-    VALUE wait_timeout = Qnil;
-    if (timeout->finite) {
-        double remaining = timeout->deadline - vector_monotonic_now();
-        if (remaining <= 0) return false;
-        wait_timeout = DBL2NUM(remaining);
-    }
-    return containers_wait_for_readable(fd, wait_timeout);
-}
-
 static VALUE
 vector_wait_body(VALUE opaque)
 {
     vector_wait_context_t *context = (vector_wait_context_t *)opaque;
-    return vector_wait_for_descriptor(context->waiter.read_fd, context->timeout) ? Qtrue : Qfalse;
+    return containers_waiter_wait(
+        &context->waiter.notification, &context->vector->lock,
+        context->timeout->finite, context->timeout->deadline, NULL
+    ) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -292,8 +258,7 @@ vector_wait_cleanup(VALUE opaque)
         }
     }
     pthread_mutex_unlock(&context->vector->lock);
-    close(context->waiter.read_fd);
-    close(context->waiter.write_fd);
+    containers_waiter_close(&context->waiter.notification);
     return Qnil;
 }
 
@@ -303,24 +268,12 @@ vector_wait_cleanup(VALUE opaque)
 static bool
 vector_wait_once(vector_t *vector, vector_timeout_t *timeout)
 {
-    int descriptors[2];
-    if (pipe(descriptors) != 0) {
-        pthread_mutex_unlock(&vector->lock);
-        rb_sys_fail("pipe");
-    }
-    vector_set_fd_flags(descriptors[0]);
-    vector_set_fd_flags(descriptors[1]);
-
     vector_wait_context_t context = {
         .vector = vector,
-        .waiter = {
-            .read_fd = descriptors[0],
-            .write_fd = descriptors[1],
-            .notified = false,
-            .next = vector->waiters,
-        },
+        .waiter = {.next = vector->waiters},
         .timeout = timeout,
     };
+    containers_waiter_init(&context.waiter.notification);
     vector->waiters = &context.waiter;
     pthread_mutex_unlock(&vector->lock);
     return RTEST(rb_ensure(vector_wait_body, (VALUE)&context, vector_wait_cleanup, (VALUE)&context));
@@ -1049,7 +1002,7 @@ vector_wait_until_changed(int argc, VALUE *argv, VALUE self)
         uint64_t generation;
         size_t index;
         pthread_mutex_lock(&vector->lock);
-        if (!vector_wait_for_reservation_locked(vector, &timeout)) return Qnil;
+        if (!vector_wait_for_reservation_locked(vector, &timeout)) return rb_block_given_p() ? rb_yield(Qnil) : Qnil;
         VALUE current = vector_lookup_index(vector, raw, &index) ? vector->values[index] : Qnil;
         generation = vector->generation;
         pthread_mutex_unlock(&vector->lock);
@@ -1057,12 +1010,12 @@ vector_wait_until_changed(int argc, VALUE *argv, VALUE self)
         if (!vector_values_equal(vector, current, expected)) return current;
 
         pthread_mutex_lock(&vector->lock);
-        if (!vector_wait_for_reservation_locked(vector, &timeout)) return Qnil;
+        if (!vector_wait_for_reservation_locked(vector, &timeout)) return rb_block_given_p() ? rb_yield(Qnil) : Qnil;
         if (vector->generation != generation) {
             pthread_mutex_unlock(&vector->lock);
             continue;
         }
-        if (!vector_wait_once(vector, &timeout)) return Qnil;
+        if (!vector_wait_once(vector, &timeout)) return rb_block_given_p() ? rb_yield(Qnil) : Qnil;
     }
 }
 

data/ext/farce/weak_map.c

@@ -250,7 +250,7 @@ weak_map_memsize(const void *pointer)
 }
 
 static const rb_data_type_t weak_map_type = {
-    .wrap_struct_name = "Ractor::Containers::WeakMap",
+    .wrap_struct_name = "Farce::Internal::WeakMap",
     .function = {
         .dmark = weak_map_mark,
         .dfree = weak_map_free,
@@ -1173,9 +1173,15 @@ weak_map_modify_body(VALUE opaque)
 }
 
 static VALUE
-weak_map_modify(VALUE self, VALUE key)
+weak_map_modify(int argc, VALUE *argv, VALUE self)
 {
     rb_check_frozen(self);
+    VALUE key;
+    VALUE keywords = Qnil;
+    VALUE keyword_values[1] = {Qundef};
+    ID keyword_ids[] = {rb_intern("timeout")};
+    rb_scan_args(argc, argv, "1:", &key, &keywords);
+    if (!NIL_P(keywords)) rb_get_kwargs(keywords, keyword_ids, 0, 1, keyword_values);
     rb_need_block();
     weak_map_t *map = get_weak_map(self);
     key = weak_map_prepare_key(map, key);
@@ -1187,8 +1193,11 @@ weak_map_modify(VALUE self, VALUE key)
     };
     operation.hash = weak_map_key_hash(map, key);
     rb_check_frozen(self);
+    weak_map_timeout_t timeout = weak_map_parse_timeout(
+        keyword_values[0] == Qundef ? Qnil : keyword_values[0]
+    );
     weak_map_execution_context_t execution = {.self = self};
-    weak_map_lock_for_key(map, key, operation.hash, &execution);
+    if (!weak_map_lock_for_key_with_timeout(map, key, operation.hash, &timeout, &execution)) return Qfalse;
     bool found;
     size_t index = weak_map_find_slot(map, key, operation.hash, &found, &execution);
     if (RB_OBJ_FROZEN(self)) {
@@ -1675,7 +1684,7 @@ define_weak_map_methods(VALUE klass)
     rb_define_method(klass, "store", weak_map_store_with_timeout, -1);
     rb_define_method(klass, "swap", weak_map_swap, -1);
     rb_define_method(klass, "update", weak_map_update, -1);
-    rb_define_method(klass, "modify", weak_map_modify, 1);
+    rb_define_method(klass, "modify", weak_map_modify, -1);
     rb_define_method(klass, "wait_until_changed", weak_map_wait_until_changed, -1);
     rb_define_method(klass, "wait_until_non_nil", weak_map_wait_until_non_nil, -1);
     rb_define_method(klass, "store_if_absent", weak_map_store_if_absent, -1);

data/ext/java/org/farce/PriorityQueue.java

@@ -54,7 +54,8 @@ public final class PriorityQueue {
     private final Consumer<Runnable> committer;
     private final QueueSignal signal;
     private final BooleanSupplier scheduled;
-    private final long capacity;
+    private long capacity;
+    private Object rubyCapacity;
     private final boolean trackAge;
     private long size;
     private long generation;
@@ -70,7 +71,7 @@ public final class PriorityQueue {
                          BiPredicate<Object, Object> identical,
                          BiPredicate<Object, Object> match,
                          Consumer<Runnable> committer,
-                         BooleanSupplier scheduled, long capacity, QueueSignal signal,
+                         BooleanSupplier scheduled, long capacity, Object rubyCapacity, QueueSignal signal,
                          boolean trackAge) {
         this.tree = new TreeMap<>(comparator);
         this.snapshot = snapshot;
@@ -82,6 +83,7 @@ public final class PriorityQueue {
         this.signal = signal;
         this.scheduled = scheduled;
         this.capacity = capacity;
+        this.rubyCapacity = rubyCapacity;
         this.trackAge = trackAge;
     }
 
@@ -302,6 +304,20 @@ public final class PriorityQueue {
         }
     }
 
+    public Object getCapacity() {
+        enter();
+        try { return rubyCapacity; } finally { lock.unlock(); }
+    }
+
+    public void setCapacity(long capacity, Object rubyCapacity) {
+        enter();
+        try { commit(() -> {
+            this.capacity = capacity;
+            this.rubyCapacity = rubyCapacity;
+        }); }
+        finally { lock.unlock(); }
+    }
+
     public long size() {
         enter();
         try { return size; } finally { lock.unlock(); }

data/lib/farce/abstract/concurrent_map.rb

@@ -5,6 +5,9 @@
 module Farce
   module Abstract
     # @abstract Super class for {Map maps} with added concurrency features.
+    #
+    # Maps implement most of the interface provided by Hash,
+    # as well as `Concurrent::Map` from the `concurrent-ruby` gem.
     class ConcurrentMap < Map
       include DuplicableMap
 
@@ -34,6 +37,24 @@ module Farce
         end
       end
 
+      # Return an existing value or store a default for an absent key.
+      # A block takes precedence over the default and receives the original key.
+      # The lookup and store are separate operations. Concurrent writes can be overwritten.
+      # @param key [BasicObject] The key to look up or store.
+      # @param defaults [Array<BasicObject>] At most one default value to store when the key is absent.
+      # @see #store For supported transfer and timeout options.
+      # @yieldparam key [BasicObject] The original key.
+      # @yieldreturn [BasicObject] The value to store.
+      # @return [BasicObject, nil] The existing or newly stored value.
+      # @raise [KeyError] If the key is absent and neither a default nor a block is provided.
+      def fetch_or_store(key, *defaults, **)
+        if defaults.size > 1
+          raise ArgumentError, "wrong number of arguments (given #{defaults.size + 1}, expected 1..2)"
+        end
+        return fetch(key) if defaults.empty? && !block_given?
+        fetch(key) { store(key, block_given? ? yield(key) : defaults.first, **) }
+      end
+
       # Read the value associated with a key, waiting for atomic-update access if necessary.
       # @param key [BasicObject] The key to look up.
       # @param timeout [Numeric, nil] The maximum number of seconds to wait for access.
@@ -43,6 +64,12 @@ module Farce
       #   The associated value, nil if the key is absent, or the fallback result if the operation times out.
       def get(key, timeout: nil, &) = internal_map.get(key, timeout:, &)
 
+      # Sets a value and returns the previous value.
+      # @param key [BasicObject] The key to update.
+      # @param value [BasicObject] The value to store.
+      # @return [BasicObject, nil] The previous value, or nil if the key was absent.
+      def get_and_set(...) = swap(...)
+
       # Associate a value with a key, waiting for atomic-update access if necessary.
       # @param key [BasicObject] The key to store.
       # @param value [BasicObject] The value to store.
@@ -52,6 +79,9 @@ module Farce
       # @return [BasicObject, nil] `value` on success, or the fallback result or nil on timeout.
       def store(key, value, timeout: nil, &) = internal_map.store(key, value, timeout:, &)
 
+      # (see #store)
+      def put(...) = store(...)
+
       # Replace the value associated with a key and return its previous value.
       # @param key [BasicObject] The key to update.
       # @param replacement [BasicObject] The value to store.
@@ -71,6 +101,69 @@ module Farce
       # @raise [LocalJumpError] If no block is given.
       def store_if_absent(key, timeout: nil, &) = internal_map.store_if_absent(key, timeout:, &)
 
+      # (see #store_if_absent)
+      def compute_if_absent(...) = store_if_absent(...)
+
+      # Atomically store a value only when the key is absent.
+      # Existing nil and false values are preserved.
+      # @param key [BasicObject] The key to look up or store.
+      # @param value [BasicObject] The value to store when the key is absent.
+      # @see #store_if_absent For supported transfer and timeout options.
+      # @return [BasicObject, nil] The existing value, or nil when a value was inserted or access timed out.
+      def put_if_absent(key, value, **)
+        inserted = false
+        previous = store_if_absent(key, **) do
+          inserted = true
+          value
+        end
+        inserted ? nil : previous
+      end
+
+      # Atomically replace an existing value and return its previous value.
+      # An absent key is left unchanged. Existing nil and false values can be replaced.
+      # @param key [BasicObject] The key to update.
+      # @param replacement [BasicObject] The value to store.
+      # @param timeout [Numeric, nil] The maximum number of seconds to wait for access.
+      # @see #store For supported transfer options.
+      # @return [BasicObject, nil] The previous value, or nil when the key is absent or access timed out.
+      def replace_if_exists(key, replacement, timeout: nil, **)
+        map = internal_map
+        previous = nil
+        changed = map.modify(key, timeout:) do |present, value|
+          next Internal::MAP_KEEP unless present
+          previous = value
+          map.check_mutation
+          wrap_value(replacement, **)
+        end
+        unwrap_value(previous) if changed
+      end
+
+      # Atomically replace the value associated with a key if it is present.
+      # The block receives the current value and should return the new value to store.
+      # The block is not called for an absent key. A stored nil is passed to the block.
+      # @param key [BasicObject] The key to update.
+      # @param timeout [Numeric, nil] The maximum number of seconds to wait for access.
+      # @yield [value] Called with the current value if the key is present.
+      # @yieldparam value [BasicObject] The current value.
+      # @yieldreturn [BasicObject] The new value to store.
+      # @return [BasicObject, nil] The newly stored value, or nil if the key was absent or the operation timed out.
+      # @raise [LocalJumpError] If no block is given.
+      def store_if_present(key, timeout: nil)
+        raise LocalJumpError, "no block given" unless block_given?
+        map = internal_map
+        result = nil
+        changed = map.modify(key, timeout:) do |present, value|
+          next Internal::MAP_KEEP unless present
+          replacement = yield(unwrap_value(value))
+          map.check_mutation
+          result = wrap_value(replacement)
+        end
+        unwrap_value(result) if changed
+      end
+
+      # (see #store_if_present)
+      def compute_if_present(...) = store_if_present(...)
+
       # Atomically replace a value if the key is present and its current value matches `expected`.
       # The configured value-comparison mode determines whether matching uses equality or identity.
       # @param key [BasicObject] The key to update.
@@ -82,6 +175,23 @@ module Farce
         internal_map.compare_and_set(key, expected, replacement, timeout:)
       end
 
+      # (see #compare_and_set)
+      def replace_pair(...) = compare_and_set(...)
+
+      # Atomically remove a key if its current value matches `expected`.
+      # The configured value-comparison mode determines whether matching uses equality or identity.
+      # Missing keys and mismatched values are left unchanged.
+      # @param key [BasicObject] The key to remove.
+      # @param expected [BasicObject] The expected current value.
+      # @param timeout [Numeric, nil] The maximum number of seconds to wait for access.
+      # @return [Boolean] Whether the entry was removed. Returns false on timeout.
+      def delete_pair(key, expected, timeout: nil)
+        expected = wrap_comparison(expected)
+        internal_map.modify(key, timeout:) do |present, value|
+          present && values_equal?(value, expected) ? Internal::MAP_DELETE : Internal::MAP_KEEP
+        end
+      end
+
       # Atomically replace the value associated with a key with the block result.
       # The block receives nil when the key is absent or its current value is nil.
       # @param key [BasicObject] The key to update.
@@ -93,6 +203,9 @@ module Farce
       # @raise [LocalJumpError] If no block is given.
       def update(key, timeout: nil, &) = internal_map.update(key, timeout:, &)
 
+      # (see #update)
+      def compute(...) = update(...)
+
       # Atomically insert `initial` for an absent key or replace an existing value with the block result.
       # The block is not called when the key is absent.
       # @param key [BasicObject] The key to insert or update.
@@ -105,6 +218,9 @@ module Farce
       # @raise [LocalJumpError] If no block is given.
       def upsert(key, initial, timeout: nil, &) = internal_map.upsert(key, initial, timeout:, &)
 
+      # (see #upsert)
+      def merge_pair(...) = upsert(...)
+
       # Wait until a block condition matches the current value.
       # One timeout budget covers all checks and waits. The block is not interrupted.
       # @yieldparam value [BasicObject, nil] the current value
@@ -344,6 +460,12 @@ module Farce
 
       private
 
+      def wrap_comparison(value) = value
+
+      def values_equal?(left, right)
+        compare_values_by_identity? ? left.equal?(right) : left == right
+      end
+
       def modify_entry(key, canonical: false)
         map = internal_map
         map = map.instance_variable_get(:@map) if canonical && map.is_a?(Internal::KeyNormalizer::ConcurrentMap)

data/lib/farce/abstract/counter.rb

@@ -7,6 +7,22 @@ module Farce
     # @abstract Common numeric interface and atomic operations for counters.
     # @note This is a module rather than a class so {Farce::Counter} can inherit
     #   directly from the native counter and avoid delegation overhead.
+    #
+    # @!method initial
+    #   @return [Integer] The initial value retained by reset and copies.
+    #
+    # @!method value
+    #   @return [Integer] The current value of the counter.
+    #
+    # @!method increment(by = 1)
+    #   Increment the counter by the given amount (default is 1).
+    #   @param [Numeric, String, #to_int] by The amount, converted to an Integer.
+    #   @return [self] Returns self for chaining.
+    #
+    # @!method decrement(by = 1)
+    #   Decrement the counter by the given amount (default is 1).
+    #   @param [Numeric, String, #to_int] by The amount, converted to an Integer.
+    #   @return [self] Returns self for chaining.
     module Counter
       include Internal::MarshalSupport::Counter
       include Internal::Copyable
@@ -24,6 +40,24 @@ module Farce
       include Value
       include Internal::ValueSerialization
 
+      # Pass the current value to the given block, replacing it with the block's result.
+      # May retry if the value changes during the block's execution.
+      #
+      # Provided for compatibility with `Concurrent::AtomicFixnum`.
+      #
+      # @yield [count] Calculate the new value based on the current value.
+      # @yieldparam count [Integer] the current value of the atomic fixnum.
+      # @yieldreturn [Integer] the new value to replace the current value.
+      # @return [Integer] the new value after the block has been applied.
+      def update
+        raise LocalJumpError, "no block given" unless block_given?
+        while true
+          current   = value
+          new_value = yield(current)
+          return new_value if compare_and_set(current, new_value)
+        end
+      end
+
       # Wait until the current value differs from the expected value.
       # @param expected [Integer] the value to wait to change from
       # @param timeout [Numeric, nil] the total seconds available
@@ -35,7 +69,7 @@ module Farce
           observed = signal.generation
           current = value
           return current unless expected == current
-          break unless signal.wait(observed, timeout: Internal.remaining_timeout(deadline))
+          break unless signal.wait(observed, timeout: Clock.remaining(deadline))
         end
         yield if block_given?
       end