sprokovuln 0.2.0

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/rbx_lockable_object.rb

@@ -0,0 +1,65 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class RbxLockableObject < AbstractLockableObject
+      safe_initialization!
+
+      def initialize(*defaults)
+        super(*defaults)
+        @__Waiters__ = []
+        @__owner__   = nil
+      end
+
+      protected
+
+      def synchronize(&block)
+        if @__owner__ == Thread.current
+          yield
+        else
+          result = nil
+          Rubinius.synchronize(self) do
+            begin
+              @__owner__ = Thread.current
+              result     = yield
+            ensure
+              @__owner__ = nil
+            end
+          end
+          result
+        end
+      end
+
+      def ns_wait(timeout = nil)
+        wchan = Rubinius::Channel.new
+
+        begin
+          @__Waiters__.push wchan
+          Rubinius.unlock(self)
+          signaled = wchan.receive_timeout timeout
+        ensure
+          Rubinius.lock(self)
+
+          if !signaled && !@__Waiters__.delete(wchan)
+            # we timed out, but got signaled afterwards,
+            # so pass that signal on to the next waiter
+            @__Waiters__.shift << true unless @__Waiters__.empty?
+          end
+        end
+
+        self
+      end
+
+      def ns_signal
+        @__Waiters__.shift << true unless @__Waiters__.empty?
+        self
+      end
+
+      def ns_broadcast
+        @__Waiters__.shift << true until @__Waiters__.empty?
+        self
+      end
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/rbx_object.rb

@@ -0,0 +1,48 @@
+module Concurrent
+  module Synchronization
+
+    module RbxAttrVolatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def attr_volatile(*names)
+          names.each do |name|
+            ivar = :"@volatile_#{name}"
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                Rubinius.memory_barrier
+                #{ivar}
+              end
+
+              def #{name}=(value)
+                #{ivar} = value
+                Rubinius.memory_barrier
+              end
+            RUBY
+          end
+          names.map { |n| [n, :"#{n}="] }.flatten
+        end
+
+      end
+
+      def full_memory_barrier
+        # Rubinius instance variables are not volatile so we need to insert barrier
+        # TODO (pitr 26-Nov-2015): check comments like ^
+        Rubinius.memory_barrier
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class RbxObject < AbstractObject
+      include RbxAttrVolatile
+
+      def initialize
+        # nothing to do
+      end
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/truffle_lockable_object.rb

@@ -0,0 +1,9 @@
+module Concurrent
+  module Synchronization
+    class TruffleLockableObject < AbstractLockableObject
+      def new(*)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/truffle_object.rb

@@ -0,0 +1,31 @@
+module Concurrent
+  module Synchronization
+
+    module TruffleAttrVolatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def attr_volatile(*names)
+          # TODO may not always be available
+          attr_atomic(*names)
+        end
+      end
+
+      def full_memory_barrier
+        Truffle::System.full_memory_barrier
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class TruffleObject < AbstractObject
+      include TruffleAttrVolatile
+
+      def initialize
+        # nothing to do
+      end
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/volatile.rb

@@ -0,0 +1,34 @@
+module Concurrent
+  module Synchronization
+
+    # Volatile adds the attr_volatile class method when included.
+    #
+    # @example
+    #   class Foo
+    #     include Concurrent::Synchronization::Volatile
+    #
+    #     attr_volatile :bar
+    #
+    #     def initialize
+    #       self.bar = 1
+    #     end
+    #   end
+    #
+    #  foo = Foo.new
+    #  foo.bar
+    #  => 1
+    #  foo.bar = 2
+    #  => 2
+
+    Volatile = case
+    when Concurrent.on_cruby?
+      MriAttrVolatile
+    when Concurrent.on_jruby?
+      JRubyAttrVolatile
+    when Concurrent.on_rbx? || Concurrent.on_truffle?
+      RbxAttrVolatile
+    else
+      MriAttrVolatile
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization.rb

@@ -0,0 +1,31 @@
+require 'concurrent/utility/engine'
+
+require 'concurrent/synchronization/abstract_object'
+require 'concurrent/utility/native_extension_loader' # load native parts first
+Concurrent.load_native_extensions
+
+require 'concurrent/synchronization/mri_object'
+require 'concurrent/synchronization/jruby_object'
+require 'concurrent/synchronization/rbx_object'
+require 'concurrent/synchronization/truffle_object'
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/volatile'
+
+require 'concurrent/synchronization/abstract_lockable_object'
+require 'concurrent/synchronization/mri_lockable_object'
+require 'concurrent/synchronization/jruby_lockable_object'
+require 'concurrent/synchronization/rbx_lockable_object'
+require 'concurrent/synchronization/truffle_lockable_object'
+
+require 'concurrent/synchronization/lockable_object'
+
+require 'concurrent/synchronization/condition'
+require 'concurrent/synchronization/lock'
+
+module Concurrent
+  # {include:file:doc/synchronization.md}
+  # {include:file:doc/synchronization-notes.md}
+  module Synchronization
+  end
+end
+

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/thread_safe/synchronized_delegator.rb

@@ -0,0 +1,50 @@
+require 'delegate'
+require 'monitor'
+
+module Concurrent
+  unless defined?(SynchronizedDelegator)
+
+    # This class provides a trivial way to synchronize all calls to a given object
+    # by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
+    # around the delegated `#send`. Example:
+    #
+    #   array = [] # not thread-safe on many impls
+    #   array = SynchronizedDelegator.new([]) # thread-safe
+    #
+    # A simple `Monitor` provides a very coarse-grained way to synchronize a given
+    # object, in that it will cause synchronization for methods that have no need
+    # for it, but this is a trivial way to get thread-safety where none may exist
+    # currently on some implementations.
+    #
+    # This class is currently being considered for inclusion into stdlib, via
+    # https://bugs.ruby-lang.org/issues/8556
+    #
+    # @!visibility private
+    class SynchronizedDelegator < SimpleDelegator
+      def setup
+        @old_abort = Thread.abort_on_exception
+        Thread.abort_on_exception = true
+      end
+
+      def teardown
+        Thread.abort_on_exception = @old_abort
+      end
+
+      def initialize(obj)
+        __setobj__(obj)
+        @monitor = Monitor.new
+      end
+
+      def method_missing(method, *args, &block)
+        monitor = @monitor
+        begin
+          monitor.enter
+          super
+        ensure
+          monitor.exit
+        end
+      end
+
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/thread_safe/util/adder.rb

@@ -0,0 +1,74 @@
+require 'concurrent/thread_safe/util'
+require 'concurrent/thread_safe/util/striped64'
+
+module Concurrent
+
+  # @!visibility private
+  module ThreadSafe
+    
+    # @!visibility private
+    module Util
+
+      # A Ruby port of the Doug Lea's jsr166e.LondAdder class version 1.8
+      # available in public domain.
+      #
+      # Original source code available here:
+      # http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/LongAdder.java?revision=1.8
+      #
+      # One or more variables that together maintain an initially zero
+      # sum. When updates (method +add+) are contended across threads,
+      # the set of variables may grow dynamically to reduce contention.
+      # Method +sum+ returns the current total combined across the
+      # variables maintaining the sum.
+      #
+      # This class is usually preferable to single +Atomic+ reference when
+      # multiple threads update a common sum that is used for purposes such
+      # as collecting statistics, not for fine-grained synchronization
+      # control.  Under low update contention, the two classes have similar
+      # characteristics. But under high contention, expected throughput of
+      # this class is significantly higher, at the expense of higher space
+      # consumption.
+      # 
+      # @!visibility private
+      class Adder < Striped64
+        # Adds the given value.
+        def add(x)
+          if (current_cells = cells) || !cas_base_computed {|current_base| current_base + x}
+            was_uncontended = true
+            hash            = hash_code
+            unless current_cells && (cell = current_cells.volatile_get_by_hash(hash)) && (was_uncontended = cell.cas_computed {|current_value| current_value + x})
+              retry_update(x, hash, was_uncontended) {|current_value| current_value + x}
+            end
+          end
+        end
+
+        def increment
+          add(1)
+        end
+
+        def decrement
+          add(-1)
+        end
+
+        # Returns the current sum.  The returned value is _NOT_ an
+        # atomic snapshot: Invocation in the absence of concurrent
+        # updates returns an accurate result, but concurrent updates that
+        # occur while the sum is being calculated might not be
+        # incorporated.
+        def sum
+          x = base
+          if current_cells = cells
+            current_cells.each do |cell|
+              x += cell.value if cell
+            end
+          end
+          x
+        end
+
+        def reset
+          internal_reset(0)
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/thread_safe/util/array_hash_rbx.rb

@@ -0,0 +1,30 @@
+require 'concurrent/thread_safe/util'
+
+module Concurrent
+  module ThreadSafe
+    module Util
+      def self.make_synchronized_on_rbx(klass)
+        klass.class_eval do
+          private
+          def _mon_initialize
+            @_monitor = Monitor.new unless @_monitor # avoid double initialisation
+          end
+
+          def self.allocate
+            obj = super
+            obj.send(:_mon_initialize)
+            obj
+          end
+        end
+
+        klass.superclass.instance_methods(false).each do |method|
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args)
+              @_monitor.synchronize { super }
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/thread_safe/util/cheap_lockable.rb

@@ -0,0 +1,118 @@
+require 'concurrent/thread_safe/util'
+require 'concurrent/thread_safe/util/volatile'
+
+module Concurrent
+
+  # @!visibility private
+  module ThreadSafe
+
+    # @!visibility private
+    module Util
+
+      # Provides a cheapest possible (mainly in terms of memory usage) +Mutex+
+      # with the +ConditionVariable+ bundled in.
+      #
+      # Usage:
+      #   class A
+      #     include CheapLockable
+      #
+      #     def do_exlusively
+      #       cheap_synchronize { yield }
+      #     end
+      #
+      #     def wait_for_something
+      #       cheap_synchronize do
+      #         cheap_wait until resource_available?
+      #         do_something
+      #         cheap_broadcast # wake up others
+      #       end
+      #     end
+      #   end
+      # 
+      # @!visibility private
+      module CheapLockable
+        private
+        engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
+        if engine == 'rbx'
+          # Making use of the Rubinius' ability to lock via object headers to avoid the overhead of the extra Mutex objects.
+          def cheap_synchronize
+            Rubinius.lock(self)
+            begin
+              yield
+            ensure
+              Rubinius.unlock(self)
+            end
+          end
+
+          def cheap_wait
+            wchan = Rubinius::Channel.new
+
+            begin
+              waiters = @waiters ||= []
+              waiters.push wchan
+              Rubinius.unlock(self)
+              signaled = wchan.receive_timeout nil
+            ensure
+              Rubinius.lock(self)
+
+              unless signaled or waiters.delete(wchan)
+                # we timed out, but got signaled afterwards (e.g. while waiting to
+                # acquire @lock), so pass that signal on to the next waiter
+                waiters.shift << true unless waiters.empty?
+              end
+            end
+
+            self
+          end
+
+          def cheap_broadcast
+            waiters = @waiters ||= []
+            waiters.shift << true until waiters.empty?
+            self
+          end
+        elsif engine == 'jruby'
+          # Use Java's native synchronized (this) { wait(); notifyAll(); } to avoid the overhead of the extra Mutex objects
+          require 'jruby'
+
+          def cheap_synchronize
+            JRuby.reference0(self).synchronized { yield }
+          end
+
+          def cheap_wait
+            JRuby.reference0(self).wait
+          end
+
+          def cheap_broadcast
+            JRuby.reference0(self).notify_all
+          end
+        else
+          require 'thread'
+
+          extend Volatile
+          attr_volatile :mutex
+
+          # Non-reentrant Mutex#syncrhonize
+          def cheap_synchronize
+            true until (my_mutex = mutex) || cas_mutex(nil, my_mutex = Mutex.new)
+            my_mutex.synchronize { yield }
+          end
+
+          # Releases this object's +cheap_synchronize+ lock and goes to sleep waiting for other threads to +cheap_broadcast+, reacquires the lock on wakeup.
+          # Must only be called in +cheap_broadcast+'s block.
+          def cheap_wait
+            conditional_variable = @conditional_variable ||= ConditionVariable.new
+            conditional_variable.wait(mutex)
+          end
+
+          # Wakes up all threads waiting for this object's +cheap_synchronize+ lock.
+          # Must only be called in +cheap_broadcast+'s block.
+          def cheap_broadcast
+            if conditional_variable = @conditional_variable
+              conditional_variable.broadcast
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/thread_safe/util/power_of_two_tuple.rb

@@ -0,0 +1,38 @@
+require 'concurrent/thread_safe/util'
+require 'concurrent/tuple'
+
+module Concurrent
+
+  # @!visibility private
+  module ThreadSafe
+
+    # @!visibility private
+    module Util
+
+      # @!visibility private
+      class PowerOfTwoTuple < Concurrent::Tuple
+
+        def initialize(size)
+          raise ArgumentError, "size must be a power of 2 (#{size.inspect} provided)" unless size > 0 && size & (size - 1) == 0
+          super(size)
+        end
+
+        def hash_to_index(hash)
+          (size - 1) & hash
+        end
+
+        def volatile_get_by_hash(hash)
+          volatile_get(hash_to_index(hash))
+        end
+
+        def volatile_set_by_hash(hash, value)
+          volatile_set(hash_to_index(hash), value)
+        end
+
+        def next_in_size_table
+          self.class.new(size << 1)
+        end
+      end
+    end
+  end
+end