concurrent-ruby 0.7.0-java

data/lib/concurrent/atomic.rb

@@ -0,0 +1,91 @@
+#####################################################################
+# Attempt to check for the deprecated ruby-atomic gem and warn the
+# user that they should use the new implementation instead.
+
+if defined?(Atomic)
+  warn <<-RUBY
+[ATOMIC] Detected an `Atomic` class, which may indicate a dependency
+on the ruby-atomic gem. That gem has been deprecated and merged into
+the concurrent-ruby gem. Please use the Concurrent::Atomic class for
+atomic references and not the Atomic class.
+RUBY
+end
+#####################################################################
+
+require 'concurrent/atomic_reference/concurrent_update_error'
+require 'concurrent/atomic_reference/mutex_atomic'
+
+begin
+  # force fallback impl with FORCE_ATOMIC_FALLBACK=1
+  if /[^0fF]/ =~ ENV['FORCE_ATOMIC_FALLBACK']
+    ruby_engine = 'mutex_atomic'
+  else
+    ruby_engine = defined?(RUBY_ENGINE)? RUBY_ENGINE : 'ruby'
+  end
+
+  require "concurrent/atomic_reference/#{ruby_engine}"
+rescue LoadError
+  warn 'Compiled extensions not installed, pure Ruby Atomic will be used.'
+end
+
+if defined? Concurrent::JavaAtomic
+
+  # @!macro [attach] atomic_reference
+  #
+  #   An object reference that may be updated atomically.
+  #
+  #       Testing with ruby 2.1.2
+  #       
+  #       *** Sequential updates ***
+  #                        user     system      total        real
+  #       no lock      0.000000   0.000000   0.000000 (  0.005502)
+  #       mutex        0.030000   0.000000   0.030000 (  0.025158)
+  #       MutexAtomic  0.100000   0.000000   0.100000 (  0.103096)
+  #       CAtomic      0.040000   0.000000   0.040000 (  0.034012)
+  #       
+  #       *** Parallel updates ***
+  #                        user     system      total        real
+  #       no lock      0.010000   0.000000   0.010000 (  0.009387)
+  #       mutex        0.030000   0.010000   0.040000 (  0.032545)
+  #       MutexAtomic  0.830000   2.280000   3.110000 (  2.146622)
+  #       CAtomic      0.040000   0.000000   0.040000 (  0.038332)
+  #
+  #       Testing with jruby 1.9.3
+  #       
+  #       *** Sequential updates ***
+  #                        user     system      total        real
+  #       no lock      0.170000   0.000000   0.170000 (  0.051000)
+  #       mutex        0.370000   0.010000   0.380000 (  0.121000)
+  #       MutexAtomic  1.530000   0.020000   1.550000 (  0.471000)
+  #       JavaAtomic   0.370000   0.010000   0.380000 (  0.112000)
+  #       
+  #       *** Parallel updates ***
+  #                        user     system      total        real
+  #       no lock      0.390000   0.000000   0.390000 (  0.105000)
+  #       mutex        0.480000   0.040000   0.520000 (  0.145000)
+  #       MutexAtomic  1.600000   0.180000   1.780000 (  0.511000)
+  #       JavaAtomic   0.460000   0.010000   0.470000 (  0.131000)
+  #
+  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
+  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
+  class Concurrent::Atomic < Concurrent::JavaAtomic
+  end
+
+elsif defined? Concurrent::RbxAtomic
+
+  # @!macro atomic_reference
+  class Concurrent::Atomic < Concurrent::RbxAtomic
+  end
+
+elsif Concurrent.allow_c_native_class?('CAtomic')
+
+  # @!macro atomic_reference
+  class Concurrent::Atomic < Concurrent::CAtomic
+  end
+
+else
+
+  # @!macro atomic_reference
+  class Concurrent::Atomic < Concurrent::MutexAtomic
+  end
+end

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -0,0 +1,202 @@
+require_relative '../../extension_helper'
+Concurrent.safe_require_c_extensions
+
+module Concurrent
+
+  # @!macro [attach] atomic_boolean
+  #
+  #   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.
+  #
+  #       Testing with ruby 2.1.2
+  #       Testing with Concurrent::MutexAtomicBoolean...
+  #         2.790000   0.000000   2.790000 (  2.791454)
+  #       Testing with Concurrent::CAtomicBoolean...
+  #         0.740000   0.000000   0.740000 (  0.740206)
+  #
+  #       Testing with jruby 1.9.3
+  #       Testing with Concurrent::MutexAtomicBoolean...
+  #         5.240000   2.520000   7.760000 (  3.683000)
+  #       Testing with Concurrent::JavaAtomicBoolean...
+  #         3.340000   0.010000   3.350000 (  0.855000)
+  #
+  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
+  class MutexAtomicBoolean
+
+    # @!macro [attach] atomic_boolean_method_initialize
+    #
+    #   Creates a new `AtomicBoolean` with the given initial value.
+    #
+    #   @param [Boolean] initial the initial value
+    def initialize(initial = false)
+      @value = !!initial
+      @mutex = Mutex.new
+    end
+
+    # @!macro [attach] atomic_boolean_method_value_get
+    #
+    #   Retrieves the current `Boolean` value.
+    #
+    #   @return [Boolean] the current value
+    def value
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_value_set
+    #
+    #   Explicitly sets the value.
+    #
+    #   @param [Boolean] value the new value to be set
+    #
+    #   @return [Boolean] the current value
+    def value=(value)
+      @mutex.lock
+      @value = !!value
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_true_question
+    #
+    #   Is the current value `true`
+    #
+    #   @return [Boolean] true if the current value is `true`, else false
+    def true?
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro atomic_boolean_method_false_question
+    #
+    #   Is the current value `false`
+    #
+    #   @return [Boolean] true if the current value is `false`, else false
+    def false?
+      @mutex.lock
+      !@value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_make_true
+    #
+    #   Explicitly sets the value to true.
+    #
+    #   @return [Boolean] true is value has changed, otherwise false
+    def make_true
+      @mutex.lock
+      old = @value
+      @value = true
+      !old
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_make_false
+    #
+    #   Explicitly sets the value to false.
+    #
+    #   @return [Boolean] true is value has changed, otherwise false
+    def make_false
+      @mutex.lock
+      old = @value
+      @value = false
+      old
+    ensure
+      @mutex.unlock
+    end
+  end
+
+  if RUBY_PLATFORM == 'java'
+
+    # @!macro atomic_boolean
+    class JavaAtomicBoolean
+
+      # @!macro atomic_boolean_method_initialize
+      #
+      def initialize(initial = false)
+        @atomic = java.util.concurrent.atomic.AtomicBoolean.new(!!initial)
+      end
+
+      # @!macro atomic_boolean_method_value_get
+      #
+      def value
+        @atomic.get
+      end
+
+      # @!macro atomic_boolean_method_value_set
+      #
+      def value=(value)
+        @atomic.set(!!value)
+      end
+
+      # @!macro atomic_boolean_method_true_question
+      def true?
+        @atomic.get
+      end
+
+      # @!macro atomic_boolean_method_false_question
+      def false?
+        !@atomic.get
+      end
+
+      # @!macro atomic_boolean_method_make_true
+      def make_true
+        @atomic.compareAndSet(false, true)
+      end
+
+      # @!macro atomic_boolean_method_make_false
+      def make_false
+        @atomic.compareAndSet(true, false)
+      end
+    end
+
+    # @!macro atomic_boolean
+    class AtomicBoolean < JavaAtomicBoolean
+    end
+
+  elsif Concurrent.allow_c_native_class?('CAtomicBoolean')
+
+    # @!macro atomic_boolean
+    class CAtomicBoolean
+
+      # @!method initialize
+      #   @!macro atomic_boolean_method_initialize
+
+      # @!method value
+      #   @!macro atomic_boolean_method_value_get
+
+      # @!method value=
+      #   @!macro atomic_boolean_method_value_set
+
+      # @!method true?
+      #   @!macro atomic_boolean_method_true_question
+
+      # @!method false?
+      #   @!macro atomic_boolean_method_false_question
+
+      # @!method make_true
+      #   @!macro atomic_boolean_method_make_true
+
+      # @!method make_false
+      #   @!macro atomic_boolean_method_make_false
+    end
+
+    # @!macro atomic_boolean
+    class AtomicBoolean < CAtomicBoolean
+    end
+
+  else
+
+    # @!macro atomic_boolean
+    class AtomicBoolean < MutexAtomicBoolean
+    end
+  end
+end

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -0,0 +1,203 @@
+require_relative '../../extension_helper'
+Concurrent.safe_require_c_extensions
+
+module Concurrent
+
+  # @!macro [attach] atomic_fixnum
+  #
+  #   A numeric value that can be updated atomically. Reads and writes to an atomic
+  #   fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
+  #   briefly but no explicit locking is required.
+  #
+  #       Testing with ruby 2.1.2
+  #       Testing with Concurrent::MutexAtomicFixnum...
+  #         3.130000   0.000000   3.130000 (  3.136505)
+  #       Testing with Concurrent::CAtomicFixnum...
+  #         0.790000   0.000000   0.790000 (  0.785550)
+  #
+  #       Testing with jruby 1.9.3
+  #       Testing with Concurrent::MutexAtomicFixnum...
+  #         5.460000   2.460000   7.920000 (  3.715000)
+  #       Testing with Concurrent::JavaAtomicFixnum...
+  #         4.520000   0.030000   4.550000 (  1.187000)
+  #
+  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
+  class MutexAtomicFixnum
+
+    # http://stackoverflow.com/questions/535721/ruby-max-integer
+    MIN_VALUE = -(2**(0.size * 8 -2))
+    MAX_VALUE = (2**(0.size * 8 -2) -1)
+
+    # @!macro [attach] atomic_fixnum_method_initialize
+    #
+    #   Creates a new `AtomicFixnum` with the given initial value.
+    #
+    #   @param [Fixnum] init the initial value
+    #   @raise [ArgumentError] if the initial value is not a `Fixnum`
+    def initialize(init = 0)
+      raise ArgumentError.new('initial value must be a Fixnum') unless init.is_a?(Fixnum)
+      @value = init
+      @mutex = Mutex.new
+    end
+
+    # @!macro [attach] atomic_fixnum_method_value_get
+    #
+    #   Retrieves the current `Fixnum` value.
+    #
+    #   @return [Fixnum] the current value
+    def value
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_fixnum_method_value_set
+    #
+    #   Explicitly sets the value.
+    #
+    #   @param [Fixnum] value the new value to be set
+    #
+    #   @return [Fixnum] the current value
+    #
+    #   @raise [ArgumentError] if the new value is not a `Fixnum`
+    def value=(value)
+      raise ArgumentError.new('value must be a Fixnum') unless value.is_a?(Fixnum)
+      @mutex.lock
+      @value = value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_fixnum_method_increment
+    #
+    #   Increases the current value by 1.
+    #
+    #   @return [Fixnum] the current value after incrementation
+    def increment
+      @mutex.lock
+      @value += 1
+    ensure
+      @mutex.unlock
+    end
+
+    alias_method :up, :increment
+
+    # @!macro [attach] atomic_fixnum_method_decrement
+    #
+    #   Decreases the current value by 1.
+    #
+    #   @return [Fixnum] the current value after decrementation
+    def decrement
+      @mutex.lock
+      @value -= 1
+    ensure
+      @mutex.unlock
+    end
+
+    alias_method :down, :decrement
+
+    # @!macro [attach] atomic_fixnum_method_compare_and_set
+    # 
+    #   Atomically sets the value to the given updated value if the current
+    #   value == the expected value.
+    #
+    #   @param [Fixnum] expect the expected value
+    #   @param [Fixnum] update the new value
+    #
+    #   @return [Boolean] true if the value was updated else false 
+    def compare_and_set(expect, update)
+      @mutex.lock
+      if @value == expect
+        @value = update
+        true
+      else
+        false
+      end
+    ensure
+      @mutex.unlock
+    end
+  end
+
+  if RUBY_PLATFORM == 'java'
+
+    # @!macro atomic_fixnum
+    class JavaAtomicFixnum
+
+      MIN_VALUE = Java::JavaLang::Long::MIN_VALUE
+      MAX_VALUE = Java::JavaLang::Long::MAX_VALUE
+
+      # @!macro atomic_fixnum_method_initialize
+      def initialize(init = 0)
+        raise ArgumentError.new('initial value must be a Fixnum') unless init.is_a?(Fixnum)
+        @atomic = java.util.concurrent.atomic.AtomicLong.new(init)
+      end
+
+      # @!macro atomic_fixnum_method_value_get
+      def value
+        @atomic.get
+      end
+
+      # @!macro atomic_fixnum_method_value_set
+      def value=(value)
+        raise ArgumentError.new('value must be a Fixnum') unless value.is_a?(Fixnum)
+        @atomic.set(value)
+      end
+
+      # @!macro atomic_fixnum_method_increment
+      def increment
+        @atomic.increment_and_get
+      end
+      alias_method :up, :increment
+
+      # @!macro atomic_fixnum_method_decrement
+      def decrement
+        @atomic.decrement_and_get
+      end
+      alias_method :down, :decrement
+
+      # @!macro atomic_fixnum_method_compare_and_set
+      def compare_and_set(expect, update)
+        @atomic.compare_and_set(expect, update)
+      end
+    end
+
+    # @!macro atomic_fixnum
+    class AtomicFixnum < JavaAtomicFixnum
+    end
+
+  elsif Concurrent.allow_c_native_class?('CAtomicFixnum')
+
+    # @!macro atomic_fixnum
+    class CAtomicFixnum
+
+      # @!method initialize
+      #   @!macro atomic_fixnum_method_initialize
+
+      # @!method value
+      #   @!macro atomic_fixnum_method_value_get
+
+      # @!method value=
+      #   @!macro atomic_fixnum_method_value_set
+
+      # @!method increment
+      #   @!macro atomic_fixnum_method_increment
+
+      # @!method decrement
+      #   @!macro atomic_fixnum_method_decrement
+
+      # @!method compare_and_set
+      #   @!macro atomic_fixnum_method_compare_and_set
+    end
+
+    # @!macro atomic_fixnum
+    class AtomicFixnum < CAtomicFixnum
+    end
+
+  else
+
+    # @!macro atomic_fixnum
+    class AtomicFixnum < MutexAtomicFixnum
+    end
+  end
+end