concurrent-ruby 0.9.2 → 1.0.0.pre1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (77) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +15 -1
  3. data/README.md +67 -68
  4. data/lib/concurrent.rb +14 -1
  5. data/lib/concurrent/array.rb +38 -0
  6. data/lib/concurrent/async.rb +0 -17
  7. data/lib/concurrent/atomic/abstract_thread_local_var.rb +40 -0
  8. data/lib/concurrent/atomic/atomic_boolean.rb +81 -118
  9. data/lib/concurrent/atomic/atomic_fixnum.rb +98 -162
  10. data/lib/concurrent/atomic/atomic_reference.rb +0 -7
  11. data/lib/concurrent/atomic/count_down_latch.rb +62 -103
  12. data/lib/concurrent/atomic/cyclic_barrier.rb +2 -0
  13. data/lib/concurrent/atomic/java_count_down_latch.rb +39 -0
  14. data/lib/concurrent/atomic/java_thread_local_var.rb +50 -0
  15. data/lib/concurrent/atomic/mutex_atomic_boolean.rb +60 -0
  16. data/lib/concurrent/atomic/mutex_atomic_fixnum.rb +91 -0
  17. data/lib/concurrent/atomic/mutex_count_down_latch.rb +43 -0
  18. data/lib/concurrent/atomic/mutex_semaphore.rb +115 -0
  19. data/lib/concurrent/atomic/ruby_thread_local_var.rb +172 -0
  20. data/lib/concurrent/atomic/semaphore.rb +84 -178
  21. data/lib/concurrent/atomic/thread_local_var.rb +63 -294
  22. data/lib/concurrent/atomic_reference/mutex_atomic.rb +14 -8
  23. data/lib/concurrent/atomics.rb +0 -33
  24. data/lib/concurrent/collection/java_non_concurrent_priority_queue.rb +84 -0
  25. data/lib/concurrent/collection/map/atomic_reference_map_backend.rb +921 -0
  26. data/lib/concurrent/collection/map/mri_map_backend.rb +66 -0
  27. data/lib/concurrent/collection/map/non_concurrent_map_backend.rb +142 -0
  28. data/lib/concurrent/collection/map/synchronized_map_backend.rb +86 -0
  29. data/lib/concurrent/collection/non_concurrent_priority_queue.rb +143 -0
  30. data/lib/concurrent/collection/ruby_non_concurrent_priority_queue.rb +150 -0
  31. data/lib/concurrent/concern/logging.rb +1 -1
  32. data/lib/concurrent/concern/obligation.rb +0 -12
  33. data/lib/concurrent/configuration.rb +18 -148
  34. data/lib/concurrent/delay.rb +5 -4
  35. data/lib/concurrent/exchanger.rb +327 -41
  36. data/lib/concurrent/executor/abstract_executor_service.rb +134 -0
  37. data/lib/concurrent/executor/executor.rb +4 -29
  38. data/lib/concurrent/executor/executor_service.rb +23 -359
  39. data/lib/concurrent/executor/immediate_executor.rb +3 -2
  40. data/lib/concurrent/executor/java_executor_service.rb +100 -0
  41. data/lib/concurrent/executor/java_single_thread_executor.rb +3 -2
  42. data/lib/concurrent/executor/java_thread_pool_executor.rb +3 -4
  43. data/lib/concurrent/executor/ruby_executor_service.rb +72 -0
  44. data/lib/concurrent/executor/ruby_single_thread_executor.rb +7 -5
  45. data/lib/concurrent/executor/ruby_thread_pool_executor.rb +3 -11
  46. data/lib/concurrent/executor/safe_task_executor.rb +1 -1
  47. data/lib/concurrent/executor/serial_executor_service.rb +34 -0
  48. data/lib/concurrent/executor/serialized_execution.rb +8 -31
  49. data/lib/concurrent/executor/serialized_execution_delegator.rb +28 -0
  50. data/lib/concurrent/executor/simple_executor_service.rb +1 -10
  51. data/lib/concurrent/executor/timer_set.rb +4 -8
  52. data/lib/concurrent/executors.rb +13 -2
  53. data/lib/concurrent/future.rb +2 -2
  54. data/lib/concurrent/hash.rb +35 -0
  55. data/lib/concurrent/ivar.rb +9 -14
  56. data/lib/concurrent/map.rb +178 -0
  57. data/lib/concurrent/promise.rb +2 -2
  58. data/lib/concurrent/scheduled_task.rb +9 -69
  59. data/lib/concurrent/thread_safe/synchronized_delegator.rb +50 -0
  60. data/lib/concurrent/thread_safe/util.rb +23 -0
  61. data/lib/concurrent/thread_safe/util/adder.rb +71 -0
  62. data/lib/concurrent/thread_safe/util/array_hash_rbx.rb +28 -0
  63. data/lib/concurrent/thread_safe/util/cheap_lockable.rb +115 -0
  64. data/lib/concurrent/thread_safe/util/power_of_two_tuple.rb +37 -0
  65. data/lib/concurrent/thread_safe/util/striped64.rb +236 -0
  66. data/lib/concurrent/thread_safe/util/volatile.rb +73 -0
  67. data/lib/concurrent/thread_safe/util/xor_shift_random.rb +48 -0
  68. data/lib/concurrent/timer_task.rb +3 -3
  69. data/lib/concurrent/tuple.rb +86 -0
  70. data/lib/concurrent/version.rb +2 -2
  71. metadata +37 -10
  72. data/lib/concurrent/atomic/condition.rb +0 -78
  73. data/lib/concurrent/collection/priority_queue.rb +0 -360
  74. data/lib/concurrent/utilities.rb +0 -5
  75. data/lib/concurrent/utility/timeout.rb +0 -39
  76. data/lib/concurrent/utility/timer.rb +0 -26
  77. data/lib/concurrent_ruby.rb +0 -2
@@ -0,0 +1,66 @@
1
+ require 'thread'
2
+ require 'concurrent/collection/map/non_concurrent_map_backend'
3
+
4
+ module Concurrent
5
+
6
+ # @!visibility private
7
+ module Collection
8
+
9
+ # @!visibility private
10
+ class MriMapBackend < NonConcurrentMapBackend
11
+
12
+ def initialize(options = nil)
13
+ super(options)
14
+ @write_lock = Mutex.new
15
+ end
16
+
17
+ def []=(key, value)
18
+ @write_lock.synchronize { super }
19
+ end
20
+
21
+ def compute_if_absent(key)
22
+ if stored_value = _get(key) # fast non-blocking path for the most likely case
23
+ stored_value
24
+ else
25
+ @write_lock.synchronize { super }
26
+ end
27
+ end
28
+
29
+ def compute_if_present(key)
30
+ @write_lock.synchronize { super }
31
+ end
32
+
33
+ def compute(key)
34
+ @write_lock.synchronize { super }
35
+ end
36
+
37
+ def merge_pair(key, value)
38
+ @write_lock.synchronize { super }
39
+ end
40
+
41
+ def replace_pair(key, old_value, new_value)
42
+ @write_lock.synchronize { super }
43
+ end
44
+
45
+ def replace_if_exists(key, new_value)
46
+ @write_lock.synchronize { super }
47
+ end
48
+
49
+ def get_and_set(key, value)
50
+ @write_lock.synchronize { super }
51
+ end
52
+
53
+ def delete(key)
54
+ @write_lock.synchronize { super }
55
+ end
56
+
57
+ def delete_pair(key, value)
58
+ @write_lock.synchronize { super }
59
+ end
60
+
61
+ def clear
62
+ @write_lock.synchronize { super }
63
+ end
64
+ end
65
+ end
66
+ end
@@ -0,0 +1,142 @@
1
+ module Concurrent
2
+
3
+ # @!visibility private
4
+ module Collection
5
+
6
+ # @!visibility private
7
+ class NonConcurrentMapBackend
8
+
9
+ # WARNING: all public methods of the class must operate on the @backend
10
+ # directly without calling each other. This is important because of the
11
+ # SynchronizedMapBackend which uses a non-reentrant mutex for perfomance
12
+ # reasons.
13
+ def initialize(options = nil)
14
+ @backend = {}
15
+ end
16
+
17
+ def [](key)
18
+ @backend[key]
19
+ end
20
+
21
+ def []=(key, value)
22
+ @backend[key] = value
23
+ end
24
+
25
+ def compute_if_absent(key)
26
+ if NULL != (stored_value = @backend.fetch(key, NULL))
27
+ stored_value
28
+ else
29
+ @backend[key] = yield
30
+ end
31
+ end
32
+
33
+ def replace_pair(key, old_value, new_value)
34
+ if pair?(key, old_value)
35
+ @backend[key] = new_value
36
+ true
37
+ else
38
+ false
39
+ end
40
+ end
41
+
42
+ def replace_if_exists(key, new_value)
43
+ if NULL != (stored_value = @backend.fetch(key, NULL))
44
+ @backend[key] = new_value
45
+ stored_value
46
+ end
47
+ end
48
+
49
+ def compute_if_present(key)
50
+ if NULL != (stored_value = @backend.fetch(key, NULL))
51
+ store_computed_value(key, yield(stored_value))
52
+ end
53
+ end
54
+
55
+ def compute(key)
56
+ store_computed_value(key, yield(@backend[key]))
57
+ end
58
+
59
+ def merge_pair(key, value)
60
+ if NULL == (stored_value = @backend.fetch(key, NULL))
61
+ @backend[key] = value
62
+ else
63
+ store_computed_value(key, yield(stored_value))
64
+ end
65
+ end
66
+
67
+ def get_and_set(key, value)
68
+ stored_value = @backend[key]
69
+ @backend[key] = value
70
+ stored_value
71
+ end
72
+
73
+ def key?(key)
74
+ @backend.key?(key)
75
+ end
76
+
77
+ def value?(value)
78
+ @backend.value?(value)
79
+ end
80
+
81
+ def delete(key)
82
+ @backend.delete(key)
83
+ end
84
+
85
+ def delete_pair(key, value)
86
+ if pair?(key, value)
87
+ @backend.delete(key)
88
+ true
89
+ else
90
+ false
91
+ end
92
+ end
93
+
94
+ def clear
95
+ @backend.clear
96
+ self
97
+ end
98
+
99
+ def each_pair
100
+ dupped_backend.each_pair do |k, v|
101
+ yield k, v
102
+ end
103
+ self
104
+ end
105
+
106
+ def size
107
+ @backend.size
108
+ end
109
+
110
+ def get_or_default(key, default_value)
111
+ @backend.fetch(key, default_value)
112
+ end
113
+
114
+ alias_method :_get, :[]
115
+ alias_method :_set, :[]=
116
+ private :_get, :_set
117
+ private
118
+ def initialize_copy(other)
119
+ super
120
+ @backend = {}
121
+ self
122
+ end
123
+
124
+ def dupped_backend
125
+ @backend.dup
126
+ end
127
+
128
+ def pair?(key, expected_value)
129
+ NULL != (stored_value = @backend.fetch(key, NULL)) && expected_value.equal?(stored_value)
130
+ end
131
+
132
+ def store_computed_value(key, new_value)
133
+ if new_value.nil?
134
+ @backend.delete(key)
135
+ nil
136
+ else
137
+ @backend[key] = new_value
138
+ end
139
+ end
140
+ end
141
+ end
142
+ end
@@ -0,0 +1,86 @@
1
+ require 'concurrent/collection/map/non_concurrent_map_backend'
2
+
3
+ module Concurrent
4
+
5
+ # @!visibility private
6
+ module Collection
7
+
8
+ # @!visibility private
9
+ class SynchronizedMapBackend < NonConcurrentMapBackend
10
+
11
+ require 'mutex_m'
12
+ include Mutex_m
13
+ # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are
14
+ # not allowed to call each other.
15
+
16
+ def [](key)
17
+ synchronize { super }
18
+ end
19
+
20
+ def []=(key, value)
21
+ synchronize { super }
22
+ end
23
+
24
+ def compute_if_absent(key)
25
+ synchronize { super }
26
+ end
27
+
28
+ def compute_if_present(key)
29
+ synchronize { super }
30
+ end
31
+
32
+ def compute(key)
33
+ synchronize { super }
34
+ end
35
+
36
+ def merge_pair(key, value)
37
+ synchronize { super }
38
+ end
39
+
40
+ def replace_pair(key, old_value, new_value)
41
+ synchronize { super }
42
+ end
43
+
44
+ def replace_if_exists(key, new_value)
45
+ synchronize { super }
46
+ end
47
+
48
+ def get_and_set(key, value)
49
+ synchronize { super }
50
+ end
51
+
52
+ def key?(key)
53
+ synchronize { super }
54
+ end
55
+
56
+ def value?(value)
57
+ synchronize { super }
58
+ end
59
+
60
+ def delete(key)
61
+ synchronize { super }
62
+ end
63
+
64
+ def delete_pair(key, value)
65
+ synchronize { super }
66
+ end
67
+
68
+ def clear
69
+ synchronize { super }
70
+ end
71
+
72
+ def size
73
+ synchronize { super }
74
+ end
75
+
76
+ def get_or_default(key, default_value)
77
+ synchronize { super }
78
+ end
79
+
80
+ private
81
+ def dupped_backend
82
+ synchronize { super }
83
+ end
84
+ end
85
+ end
86
+ end
@@ -0,0 +1,143 @@
1
+ require 'concurrent/collection/java_non_concurrent_priority_queue'
2
+ require 'concurrent/collection/ruby_non_concurrent_priority_queue'
3
+ require 'concurrent/utility/engine'
4
+
5
+ module Concurrent
6
+ module Collection
7
+
8
+ # @!visibility private
9
+ # @!macro internal_implementation_note
10
+ NonConcurrentPriorityQueueImplementation = case
11
+ when Concurrent.on_jruby?
12
+ JavaNonConcurrentPriorityQueue
13
+ else
14
+ RubyNonConcurrentPriorityQueue
15
+ end
16
+ private_constant :NonConcurrentPriorityQueueImplementation
17
+
18
+ # @!macro [attach] priority_queue
19
+ #
20
+ # A queue collection in which the elements are sorted based on their
21
+ # comparison (spaceship) operator `<=>`. Items are added to the queue
22
+ # at a position relative to their priority. On removal the element
23
+ # with the "highest" priority is removed. By default the sort order is
24
+ # from highest to lowest, but a lowest-to-highest sort order can be
25
+ # set on construction.
26
+ #
27
+ # The API is based on the `Queue` class from the Ruby standard library.
28
+ #
29
+ # The pure Ruby implementation, `RubyNonConcurrentPriorityQueue` uses a heap algorithm
30
+ # stored in an array. The algorithm is based on the work of Robert Sedgewick
31
+ # and Kevin Wayne.
32
+ #
33
+ # The JRuby native implementation is a thin wrapper around the standard
34
+ # library `java.util.NonConcurrentPriorityQueue`.
35
+ #
36
+ # When running under JRuby the class `NonConcurrentPriorityQueue` extends `JavaNonConcurrentPriorityQueue`.
37
+ # When running under all other interpreters it extends `RubyNonConcurrentPriorityQueue`.
38
+ #
39
+ # @note This implementation is *not* thread safe.
40
+ #
41
+ # @see http://en.wikipedia.org/wiki/Priority_queue
42
+ # @see http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html
43
+ #
44
+ # @see http://algs4.cs.princeton.edu/24pq/index.php#2.6
45
+ # @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
46
+ #
47
+ # @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
48
+ #
49
+ # @!visibility private
50
+ class NonConcurrentPriorityQueue < NonConcurrentPriorityQueueImplementation
51
+
52
+ alias_method :has_priority?, :include?
53
+
54
+ alias_method :size, :length
55
+
56
+ alias_method :deq, :pop
57
+ alias_method :shift, :pop
58
+
59
+ alias_method :<<, :push
60
+ alias_method :enq, :push
61
+
62
+ # @!method initialize(opts = {})
63
+ # @!macro [new] priority_queue_method_initialize
64
+ #
65
+ # Create a new priority queue with no items.
66
+ #
67
+ # @param [Hash] opts the options for creating the queue
68
+ # @option opts [Symbol] :order (:max) dictates the order in which items are
69
+ # stored: from highest to lowest when `:max` or `:high`; from lowest to
70
+ # highest when `:min` or `:low`
71
+
72
+ # @!method clear
73
+ # @!macro [new] priority_queue_method_clear
74
+ #
75
+ # Removes all of the elements from this priority queue.
76
+
77
+ # @!method delete(item)
78
+ # @!macro [new] priority_queue_method_delete
79
+ #
80
+ # Deletes all items from `self` that are equal to `item`.
81
+ #
82
+ # @param [Object] item the item to be removed from the queue
83
+ # @return [Object] true if the item is found else false
84
+
85
+ # @!method empty?
86
+ # @!macro [new] priority_queue_method_empty
87
+ #
88
+ # Returns `true` if `self` contains no elements.
89
+ #
90
+ # @return [Boolean] true if there are no items in the queue else false
91
+
92
+ # @!method include?(item)
93
+ # @!macro [new] priority_queue_method_include
94
+ #
95
+ # Returns `true` if the given item is present in `self` (that is, if any
96
+ # element == `item`), otherwise returns false.
97
+ #
98
+ # @param [Object] item the item to search for
99
+ #
100
+ # @return [Boolean] true if the item is found else false
101
+
102
+ # @!method length
103
+ # @!macro [new] priority_queue_method_length
104
+ #
105
+ # The current length of the queue.
106
+ #
107
+ # @return [Fixnum] the number of items in the queue
108
+
109
+ # @!method peek
110
+ # @!macro [new] priority_queue_method_peek
111
+ #
112
+ # Retrieves, but does not remove, the head of this queue, or returns `nil`
113
+ # if this queue is empty.
114
+ #
115
+ # @return [Object] the head of the queue or `nil` when empty
116
+
117
+ # @!method pop
118
+ # @!macro [new] priority_queue_method_pop
119
+ #
120
+ # Retrieves and removes the head of this queue, or returns `nil` if this
121
+ # queue is empty.
122
+ #
123
+ # @return [Object] the head of the queue or `nil` when empty
124
+
125
+ # @!method push(item)
126
+ # @!macro [new] priority_queue_method_push
127
+ #
128
+ # Inserts the specified element into this priority queue.
129
+ #
130
+ # @param [Object] item the item to insert onto the queue
131
+
132
+ # @!method self.from_list(list, opts = {})
133
+ # @!macro [new] priority_queue_method_from_list
134
+ #
135
+ # Create a new priority queue from the given list.
136
+ #
137
+ # @param [Enumerable] list the list to build the queue from
138
+ # @param [Hash] opts the options for creating the queue
139
+ #
140
+ # @return [NonConcurrentPriorityQueue] the newly created and populated queue
141
+ end
142
+ end
143
+ end
@@ -0,0 +1,150 @@
1
+ module Concurrent
2
+ module Collection
3
+
4
+ # @!macro priority_queue
5
+ #
6
+ # @!visibility private
7
+ # @!macro internal_implementation_note
8
+ class RubyNonConcurrentPriorityQueue
9
+
10
+ # @!macro priority_queue_method_initialize
11
+ def initialize(opts = {})
12
+ order = opts.fetch(:order, :max)
13
+ @comparator = [:min, :low].include?(order) ? -1 : 1
14
+ clear
15
+ end
16
+
17
+ # @!macro priority_queue_method_clear
18
+ def clear
19
+ @queue = [nil]
20
+ @length = 0
21
+ true
22
+ end
23
+
24
+ # @!macro priority_queue_method_delete
25
+ def delete(item)
26
+ return false if empty?
27
+ original_length = @length
28
+ k = 1
29
+ while k <= @length
30
+ if @queue[k] == item
31
+ swap(k, @length)
32
+ @length -= 1
33
+ sink(k)
34
+ @queue.pop
35
+ else
36
+ k += 1
37
+ end
38
+ end
39
+ @length != original_length
40
+ end
41
+
42
+ # @!macro priority_queue_method_empty
43
+ def empty?
44
+ size == 0
45
+ end
46
+
47
+ # @!macro priority_queue_method_include
48
+ def include?(item)
49
+ @queue.include?(item)
50
+ end
51
+ alias_method :has_priority?, :include?
52
+
53
+ # @!macro priority_queue_method_length
54
+ def length
55
+ @length
56
+ end
57
+ alias_method :size, :length
58
+
59
+ # @!macro priority_queue_method_peek
60
+ def peek
61
+ empty? ? nil : @queue[1]
62
+ end
63
+
64
+ # @!macro priority_queue_method_pop
65
+ def pop
66
+ return nil if empty?
67
+ max = @queue[1]
68
+ swap(1, @length)
69
+ @length -= 1
70
+ sink(1)
71
+ @queue.pop
72
+ max
73
+ end
74
+ alias_method :deq, :pop
75
+ alias_method :shift, :pop
76
+
77
+ # @!macro priority_queue_method_push
78
+ def push(item)
79
+ raise ArgumentError.new('cannot enqueue nil') if item.nil?
80
+ @length += 1
81
+ @queue << item
82
+ swim(@length)
83
+ true
84
+ end
85
+ alias_method :<<, :push
86
+ alias_method :enq, :push
87
+
88
+ # @!macro priority_queue_method_from_list
89
+ def self.from_list(list, opts = {})
90
+ queue = new(opts)
91
+ list.each{|item| queue << item }
92
+ queue
93
+ end
94
+
95
+ private
96
+
97
+ # Exchange the values at the given indexes within the internal array.
98
+ #
99
+ # @param [Integer] x the first index to swap
100
+ # @param [Integer] y the second index to swap
101
+ #
102
+ # @!visibility private
103
+ def swap(x, y)
104
+ temp = @queue[x]
105
+ @queue[x] = @queue[y]
106
+ @queue[y] = temp
107
+ end
108
+
109
+ # Are the items at the given indexes ordered based on the priority
110
+ # order specified at construction?
111
+ #
112
+ # @param [Integer] x the first index from which to retrieve a comparable value
113
+ # @param [Integer] y the second index from which to retrieve a comparable value
114
+ #
115
+ # @return [Boolean] true if the two elements are in the correct priority order
116
+ # else false
117
+ #
118
+ # @!visibility private
119
+ def ordered?(x, y)
120
+ (@queue[x] <=> @queue[y]) == @comparator
121
+ end
122
+
123
+ # Percolate down to maintain heap invariant.
124
+ #
125
+ # @param [Integer] k the index at which to start the percolation
126
+ #
127
+ # @!visibility private
128
+ def sink(k)
129
+ while (j = (2 * k)) <= @length do
130
+ j += 1 if j < @length && ! ordered?(j, j+1)
131
+ break if ordered?(k, j)
132
+ swap(k, j)
133
+ k = j
134
+ end
135
+ end
136
+
137
+ # Percolate up to maintain heap invariant.
138
+ #
139
+ # @param [Integer] k the index at which to start the percolation
140
+ #
141
+ # @!visibility private
142
+ def swim(k)
143
+ while k > 1 && ! ordered?(k/2, k) do
144
+ swap(k, k/2)
145
+ k = k/2
146
+ end
147
+ end
148
+ end
149
+ end
150
+ end