concurrent-ruby 0.9.2 → 1.0.0.pre1

Sign up to get free protection for your applications and to get access to all the features.
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