garcun 0.0.2

data/lib/garcon/task/atomic.rb

@@ -0,0 +1,151 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Garcon
+  # Define update methods that use direct paths
+  module AtomicDirectUpdate
+
+    # 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.
+    #
+    # @yield [Object]
+    #   Calculate a new value for the atomic reference using given (old) value.
+    # @yieldparam [Object] old_value
+    #   The starting value of the atomic reference
+    #
+    # @return [Object]
+    #   The new value
+    def update
+      true until compare_and_set(old_value = get, new_value = yield(old_value))
+      new_value
+    end
+
+    # Pass the current value to the given block, replacing it with the block's
+    # result. Raise an exception if the update fails.
+    #
+    # @yield [Object]
+    #   Calculate a new value for the atomic reference using given (old) value.
+    # @yieldparam [Object] old_value
+    #   The starting value of the atomic reference.
+    #
+    # @raise [Garcon::ConcurrentUpdateError]
+    #   If the update fails
+    #
+    # @return [Object] the new value
+    def try_update
+      old_value = get
+      new_value = yield old_value
+      unless compare_and_set(old_value, new_value)
+        raise ConcurrentUpdateError, "Update failed"
+      end
+      new_value
+    end
+  end
+
+  # Special "compare and set" handling of numeric values.
+  module AtomicNumericCompareAndSetWrapper
+
+    def compare_and_set(old_value, new_value)
+      if old_value.kind_of? Numeric
+        while true
+          old = get
+
+          return false unless old.kind_of? Numeric
+
+          return false unless old == old_value
+
+          result = _compare_and_set(old, new_value)
+          return result if result
+        end
+      else
+        _compare_and_set(old_value, new_value)
+      end
+    end
+    alias_method :compare_and_swap, :compare_and_set
+  end
+
+  class AtomicMutex
+    include Garcon::AtomicDirectUpdate
+    include Garcon::AtomicNumericCompareAndSetWrapper
+
+    def initialize(value = nil)
+      @mutex = Mutex.new
+      @value = value
+    end
+
+    # Gets the current value.
+    #
+    # @return [Object]
+    #   The current value.
+    def get
+      @mutex.synchronize { @value }
+    end
+    alias_method :value, :get
+
+    # Sets to the given value.
+    #
+    # @param [Object] value
+    #   The new value to set.
+    #
+    # @return [Object]
+    #   The new value.
+    def set(value)
+      @mutex.synchronize { @value = value }
+    end
+    alias_method :value=, :set
+
+    # Atomically sets to the given value and returns the old value.
+    #
+    # @param [Object] value
+    #   The new value to set.
+    #
+    # @return [Object]
+    #   The old value.
+    def get_and_set(new_value)
+      @mutex.synchronize do
+        old_value = @value
+        @value = new_value
+        old_value
+      end
+    end
+    alias_method :swap, :get_and_set
+
+    # Atomically sets the value to the given updated value if the current value
+    # is equal the expected value.
+    #
+    # @param [Object] old_value
+    #   The expected value.
+    # @param [Object] new_value
+    #   The new value.
+    #
+    # @return [Boolean]
+    #   `true` if successful, `false` indicates that the actual value was not
+    #   equal to the expected value.
+    def _compare_and_set(old_value, new_value)
+      return false unless @mutex.try_lock
+      begin
+        return false unless @value.equal? old_value
+        @value = new_value
+      ensure
+        @mutex.unlock
+      end
+      true
+    end
+  end
+end

data/lib/garcon/task/atomic_boolean.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Garcon
+
+  # A boolean value that can be updated atomically. Reads and writes to an
+  # atomic boolean and thread-safe and guaranteed to succeed. Reads and writes
+  # may block briefly but no explicit locking is required.
+  #
+  class MutexAtomicBoolean
+
+    # Creates a new `AtomicBoolean` with the given initial value.
+    #
+    # @param [Boolean] initial
+    #   the initial value
+    #
+    # @api public
+    def initialize(initial = false)
+      @value = !!initial
+      @mutex = Mutex.new
+    end
+
+    # Retrieves the current `Boolean` value.
+    #
+    # @return [Boolean]
+    #   the current value
+    #
+    # @api public
+    def value
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # Explicitly sets the value.
+    #
+    # @param [Boolean] value
+    #   the new value to be set
+    #
+    # @return [Boolean]
+    #   the current value
+    #
+    # @api public
+    def value=(value)
+      @mutex.lock
+      @value = !!value
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # Is the current value `true`
+    #
+    # @return [Boolean]
+    #   True if the current value is `true`, else false
+    #
+    # @api public
+    def true?
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # Is the current value `false`
+    #
+    # @return [Boolean]
+    #   True if the current value is `false`, else false
+    #
+    # @api public
+    def false?
+      @mutex.lock
+      !@value
+    ensure
+      @mutex.unlock
+    end
+
+    # Explicitly sets the value to true.
+    #
+    # @return [Boolean]
+    #   True is value has changed, otherwise false
+    #
+    # @api public
+    def make_true
+      @mutex.lock
+      old = @value
+      @value = true
+      !old
+    ensure
+      @mutex.unlock
+    end
+
+    # Explicitly sets the value to false.
+    #
+    # @return [Boolean]
+    #   True is value has changed, otherwise false
+    #
+    # @api public
+    def make_false
+      @mutex.lock
+      old = @value
+      @value = false
+      old
+    ensure
+      @mutex.unlock
+    end
+  end
+
+  class AtomicBoolean < MutexAtomicBoolean; end
+end

data/lib/garcon/task/condition.rb

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative 'monotonic_time'
+
+module Garcon
+
+  # Condition is a better implementation of standard Ruby ConditionVariable. The
+  # biggest difference is the wait return value: Condition#wait returns
+  # Condition::Result which make possible to know if waiting thread has been
+  # woken up by an another thread (using #signal or #broadcast) or due to
+  # timeout.
+  #
+  # Every #wait must be guarded by a locked Mutex or a ThreadError will be
+  # risen. Although it's not mandatory, it's recommended to call also #signal
+  # and #broadcast within the same mutex
+  class Condition
+
+    class Result
+      def initialize(remaining_time)
+        @remaining_time = remaining_time
+      end
+
+      attr_reader :remaining_time
+
+      # @return [Boolean]
+      #  Returns true if current thread has been waken up by a #signal or a
+      #  #broadcast call, otherwise false.
+      def woken_up?
+        @remaining_time.nil? || @remaining_time > 0
+      end
+
+      # @return [Boolean]
+      #   Returns true if current thread has been waken up due to a timeout,
+      #   otherwise false.
+      def timed_out?
+        @remaining_time != nil && @remaining_time <= 0
+      end
+
+      alias_method :can_wait?, :woken_up?
+    end
+
+    def initialize
+      @condition = ConditionVariable.new
+    end
+
+    # @param [Mutex] mutex
+    #   The locked mutex guarding the wait.
+    #
+    # @param [Object] timeout
+    #   Nil means no timeout.
+    #
+    # @return [Result]
+    #
+    # @!macro monotonic_clock_warning
+    def wait(mutex, timeout = nil)
+      start_time = Garcon.monotonic_time
+      @condition.wait(mutex, timeout)
+
+      if timeout.nil?
+        Result.new(nil)
+      else
+        Result.new(start_time + timeout - Garcon.monotonic_time)
+      end
+    end
+
+    # Wakes up a waiting thread
+    #
+    # @return [true]
+    def signal
+      @condition.signal
+      true
+    end
+
+    # Wakes up all waiting threads
+    #
+    # @return [true]
+    def broadcast
+      @condition.broadcast
+      true
+    end
+  end
+end

data/lib/garcon/task/copy_on_notify_observer_set.rb

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Garcon
+
+  # A thread safe observer set implemented using copy-on-read approach:
+  # observers are added and removed from a thread safe collection; every time
+  # a notification is required the internal data structure is copied to
+  # prevent concurrency issues
+  class CopyOnNotifyObserverSet
+
+    def initialize
+      @mutex = Mutex.new
+      @observers = {}
+    end
+
+    # Adds an observer to this set. If a block is passed, the observer will be
+    # created by this method and no other params should be passed
+    #
+    # @param [Object] observer
+    #   The observer to add
+    #
+    # @param [Symbol] func
+    #   The function to call on the observer during notification. The default
+    #   is :update
+    #
+    # @return [Object]
+    #   the added observer
+    def add_observer(observer = nil, func = :update, &block)
+      if observer.nil? && block.nil?
+        raise ArgumentError, 'should pass observer as a first argument or block'
+      elsif observer && block
+        raise ArgumentError.new('cannot provide both an observer and a block')
+      end
+
+      if block
+        observer = block
+        func = :call
+      end
+
+      begin
+        @mutex.lock
+        @observers[observer] = func
+      ensure
+        @mutex.unlock
+      end
+
+      observer
+    end
+
+    # @param [Object] observer
+    #   the observer to remove
+    # @return [Object]
+    #   the deleted observer
+    def delete_observer(observer)
+      @mutex.lock
+      @observers.delete(observer)
+      @mutex.unlock
+
+      observer
+    end
+
+    # Deletes all observers
+    # @return [CopyOnWriteObserverSet] self
+    def delete_observers
+      @mutex.lock
+      @observers.clear
+      @mutex.unlock
+
+      self
+    end
+
+    # @return [Integer]
+    #   the observers count
+    def count_observers
+      @mutex.lock
+      result = @observers.count
+      @mutex.unlock
+
+      result
+    end
+
+    # Notifies all registered observers with optional args
+    #
+    # @param [Object] args
+    #   arguments to be passed to each observer
+    #
+    # @return [CopyOnWriteObserverSet] self
+    def notify_observers(*args, &block)
+      observers = duplicate_observers
+      notify_to(observers, *args, &block)
+
+      self
+    end
+
+    # Notifies all registered observers with optional args and deletes them.
+    #
+    # @param [Object] args
+    #   arguments to be passed to each observer
+    #
+    # @return [CopyOnWriteObserverSet] self
+    def notify_and_delete_observers(*args, &block)
+      observers = duplicate_and_clear_observers
+      notify_to(observers, *args, &block)
+
+      self
+    end
+
+    private #        P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+    def duplicate_and_clear_observers
+      @mutex.lock
+      observers = @observers.dup
+      @observers.clear
+      @mutex.unlock
+
+      observers
+    end
+
+    def duplicate_observers
+      @mutex.lock
+      observers = @observers.dup
+      @mutex.unlock
+
+      observers
+    end
+
+    def notify_to(observers, *args)
+      if block_given? && !args.empty?
+        raise ArgumentError.new 'cannot give arguments and a block'
+      end
+      observers.each do |observer, function|
+        args = yield if block_given?
+        observer.send(function, *args)
+      end
+    end
+  end
+end