concurrent-ruby-ext 0.9.2-x86-mingw32 → 1.0.0.pre1-x86-mingw32

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: d50feae93d9ce071c48a439182eccc585539840d
4
- data.tar.gz: 14a554a842b0d84050d236daaa50d7b99d696849
3
+ metadata.gz: 142e98af3ea69acb9f395397aa74c0fa68a0e7ea
4
+ data.tar.gz: 4a36a9ca55d94697f9a015f4ceee89679a1b7aae
5
5
  SHA512:
6
- metadata.gz: 852f74f0ea548ded3abbdb317b60d66af2097b251783ffd6c1f60a545cb29bd176731b19f820307aa3416969aa285e74d9b8ff8e495031006c45edfa13a78e5a
7
- data.tar.gz: 4113eca0fc106bd8fef93e295a33a0655b4d80f1dde3be3d65aa005f7f8247110ddde1c39b0e26a0b88af0126aec14f9589c79cb54d83f2f45dad2a60755a7f5
6
+ metadata.gz: 06d8dbe8054ed3f467bed077f519d96b2eb06caef7eb1f8085b9e00a9624cf4c4637934e3cabface13b8d52f473e8b65d8eaac248e49ddb46afd352e45b6dd99
7
+ data.tar.gz: 90302447a70f743c2ed97db8d7ab54d33617b70e87ae20fe557444e730cf762fdcef407a50fc79e382565986f6f96be6ffcdddeecb0d07ac38001d5b11ce4f44
data/CHANGELOG.md CHANGED
@@ -1,4 +1,18 @@
1
- ## Current Release v0.9.1 (09 August 2015)
1
+ ## Current Release v1.0.0.pre1 (19 Aug 2015)
2
+
3
+ * Merged in the `thread_safe` gem
4
+ - `Concurrent::Array`
5
+ - `Concurrent::Hash`
6
+ - `Concurrent::Map` (formerly ThreadSafe::Cache)
7
+ - `Concurrent::Tuple`
8
+ * Minor improvements to Concurrent::Map
9
+ * Complete rewrite of `Exchanger`
10
+ * Removed all deprecated code (classes, methods, constants, etc.)
11
+ * Updated Agent, MutexAtomic, and BufferedChannel to inherit from Synchronization::Object.
12
+ * Many improved tests
13
+ * Some internal reorganization
14
+
15
+ ### Release v0.9.1 (09 August 2015)
2
16
 
3
17
  * Fixed a Rubiniux bug in synchronization object
4
18
  * Fixed all interpreter warnings (except circular references)
data/README.md CHANGED
@@ -47,7 +47,7 @@
47
47
 
48
48
  MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported.
49
49
  This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
50
- Java 8 is required for JRuby (Java 7 support is deprecated in version 0.9 and will be removed in 1.0).
50
+ Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs will be supported.
51
51
 
52
52
  ## Features & Documentation
53
53
 
@@ -62,54 +62,62 @@ This library contains a variety of concurrency abstractions at high and low leve
62
62
  #### General-purpose Concurrency Abstractions
63
63
 
64
64
  * [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
65
- * [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
66
65
  * [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html): An asynchronous operation that produces a value.
67
66
  * [Dataflow](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#dataflow-class_method): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
68
67
  * [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features.
69
68
  * [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html): Like a Future scheduled for a specific future time.
70
69
  * [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals.
71
70
 
72
- #### Thread-safe Value Objects
71
+ #### Thread-safe Value Objects, Structures, and Collections
72
+
73
+ Collection classes that were originally part of the (deprecated) `thread_safe` gem:
74
+
75
+ * [Array](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Array.html) A thread-safe subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
76
+ * [Hash](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Hash.html) A thread-safe subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
77
+ * [Map](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Map.html) A hash-like object that should have much better performance characteristics, especially under high concurrency, than `Concurrent::Hash`.
78
+ * [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Tuple.html) A fixed size array with volatile (synchronized, thread safe) getters/setters.
79
+
80
+ Value objects inspired by other languages:
73
81
 
74
- * `Maybe` A thread-safe, immutable object representing an optional value, based on
82
+ * [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
83
+ * [Maybe](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Maybe.html) A thread-safe, immutable object representing an optional value, based on
75
84
  [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
76
- * `Delay` Lazy evaluation of a block yielding an immutable result. Based on Clojure's
85
+ * [Delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html) Lazy evaluation of a block yielding an immutable result. Based on Clojure's
77
86
  [delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html).
78
87
 
79
- #### Thread-safe Structures
88
+ Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
89
+
90
+ * [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ImmutableStruct.html) Immutable struct where values are set at construction and cannot be changed later.
91
+ * [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutableStruct.html) Synchronized, mutable struct where values can be safely changed at any time.
92
+ * [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/SettableStruct.html) Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
80
93
 
81
- Derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
94
+ Thread-safe variables:
82
95
 
83
- * `ImmutableStruct` Immutable struct where values are set at construction and cannot be changed later.
84
- * `MutableStruct` Synchronized, mutable struct where values can be safely changed at any time.
85
- * `SettableStruct` Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
96
+ * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html) A boolean value that can be updated atomically.
97
+ * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html) A numeric value that can be updated atomically.
98
+ * [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html) An object reference that may be updated atomically.
99
+ * [ThreadLocalVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html) A variable where the value is different for each thread.
86
100
 
87
101
  #### Java-inspired ThreadPools and Other Executors
88
102
 
89
- * See [ThreadPool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
103
+ * See the [thread pool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
90
104
 
91
105
  #### Thread Synchronization Classes and Algorithms
92
106
 
93
- * [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html)
94
- * [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
95
- * [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
96
- * [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html)
97
-
98
- #### Thread-safe Variables
99
-
100
- * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html)
101
- * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html)
102
- * [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html)
103
- * [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar)
104
- * [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar)
105
- * [Thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
106
- * [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
107
- * [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html)
108
- * [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html)
107
+ * [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html) A synchronization object that allows one thread to wait on multiple other threads.
108
+ * [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html) A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
109
+ * [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html) Old school kernel-style event.
110
+ * [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
111
+ * [I-Structure](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar) Similar to a "future" but can be manually assigned once, after which it becomes immutable.
112
+ * [M-Structure](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar) A synchronized single element container.
113
+ * [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html) A lock that supports multiple readers but only one writer.
114
+ * [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html) A read/write lock with reentrant and upgrade features.
115
+ * [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html) A counting-based locking mechanism that uses permits.
116
+ * [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar) A transactional variable - a single-element container that is used as part of a transaction.
109
117
 
110
118
  ### Edge Features
111
119
 
112
- These are available in the `concurrent-ruby-edge` companion gem, installed with `gem install concurrent-ruby-edge`.
120
+ These are available in the `concurrent-ruby-edge` companion gem.
113
121
 
114
122
  These features are under active development and may change frequently. They are expected not to
115
123
  keep backward compatibility (there may also lack tests and documentation). Semantic versions will
@@ -125,10 +133,9 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
125
133
  * [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A single atomic value that represents an identity.
126
134
  * [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html):
127
135
  Communicating Sequential Processes (CSP).
128
- * [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
129
136
  * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
130
- * [Atomic Markable Reference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
131
- * [LockFreeLinked Set](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
137
+ * [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
138
+ * [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
132
139
  * [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeStack.html)
133
140
 
134
141
  #### Statuses:
@@ -139,52 +146,21 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
139
146
  - **Future/Promise Framework** - API changes; partial documentation and tests; stability good.
140
147
  - **Agent** - Incomplete behaviour compared to Clojure's models; stability good.
141
148
  - **Channel** - Missing documentation; limted features; stability good.
142
- - **Exchanger** - Known race condition requiring a new implementation.
143
149
  - **LazyRegister** - Missing documentation and tests.
144
150
  - **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Needs real world battle testing
145
151
 
146
152
  ## Usage
147
153
 
148
- All abstractions within this gem can be loaded simply by requiring it:
154
+ Everything within this gem can be loaded simply by requiring it:
149
155
 
150
156
  ```ruby
151
157
  require 'concurrent'
152
158
  ```
153
159
 
154
- To reduce the amount of code loaded at runtime, subsets of this gem can be required:
160
+ To use the tools in the Edge gem it must be required separately:
155
161
 
156
162
  ```ruby
157
- require 'concurrent' # everything
158
-
159
- # groups
160
-
161
- require 'concurrent/atomics' # atomic and thread synchronization classes
162
- require 'concurrent/executors' # Thread pools and other executors
163
-
164
- # individual abstractions
165
-
166
- require 'concurrent/async' # Concurrent::Async
167
- require 'concurrent/atom' # Concurrent::Atom
168
- require 'concurrent/dataflow' # Concurrent::dataflow
169
- require 'concurrent/delay' # Concurrent::Delay
170
- require 'concurrent/future' # Concurrent::Future
171
- require 'concurrent/immutable_struct' # Concurrent::ImmutableStruct
172
- require 'concurrent/ivar' # Concurrent::IVar
173
- require 'concurrent/maybe' # Concurrent::Maybe
174
- require 'concurrent/mutable_struct' # Concurrent::MutableStruct
175
- require 'concurrent/mvar' # Concurrent::MVar
176
- require 'concurrent/promise' # Concurrent::Promise
177
- require 'concurrent/scheduled_task' # Concurrent::ScheduledTask
178
- require 'concurrent/settable_struct' # Concurrent::SettableStruct
179
- require 'concurrent/timer_task' # Concurrent::TimerTask
180
- require 'concurrent/tvar' # Concurrent::TVar
181
-
182
- # experimental - available in `concurrent-ruby-edge` companion gem
183
-
184
- require 'concurrent/actor' # Concurrent::Actor and supporting code
185
- require 'concurrent/edge/future' # new Future Framework
186
- require 'concurrent/agent' # Concurrent::Agent
187
- require 'concurrent/channel ' # Concurrent::Channel and supporting code
163
+ require 'concurrent-edge'
188
164
  ```
189
165
 
190
166
  If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.
@@ -203,6 +179,23 @@ gem 'concurrent-ruby'
203
179
 
204
180
  and run `bundle install` from your shell.
205
181
 
182
+ ### Edge Gem Installation
183
+
184
+ The Edge gem must be installed separately from the core gem:
185
+
186
+ ```shell
187
+ gem install concurrent-ruby-edge
188
+ ```
189
+
190
+ or add the following line to Gemfile:
191
+
192
+ ```ruby
193
+ gem 'concurrent-ruby-edge'
194
+ ```
195
+
196
+ and run `bundle install` from your shell.
197
+
198
+
206
199
  ### C Extensions for MRI
207
200
 
208
201
  Potential performance improvements may be achieved under MRI by installing optional C extensions.
@@ -240,7 +233,7 @@ The best practice is to depend on `concurrent-ruby` and let users to decide if t
240
233
 
241
234
  All published versions of this gem (core, extension, and several platform-specific packages) are compiled,
242
235
  packaged, tested, and published using an open, [automated process](https://github.com/ruby-concurrency/rake-compiler-dev-box).
243
- This process can also be used to create pre-compiled binaries of the extension gem for virtally
236
+ This process can also be used to create pre-compiled binaries of the extension gem for virtually
244
237
  any platform. *Documentation is forthcoming...*
245
238
 
246
239
  ```
@@ -272,11 +265,17 @@ bundle exec rake compile # Compile all the extensions
272
265
  ## Maintainers
273
266
 
274
267
  * [Jerry D'Antonio](https://github.com/jdantonio) (creator)
268
+ * [Petr Chalupa](https://github.com/pitr-ch)
275
269
  * [Michele Della Torre](https://github.com/mighe)
276
270
  * [Chris Seaton](https://github.com/chrisseaton)
277
- * [Lucas Allan](https://github.com/lucasallan)
278
- * [Petr Chalupa](https://github.com/pitr-ch)
279
271
  * [Paweł Obrok](https://github.com/obrok)
272
+ * [Lucas Allan](https://github.com/lucasallan)
273
+
274
+ ### Special Thanks
275
+
276
+ * [Brian Durand](https://github.com/bdurand) for the `ref` gem
277
+ * [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
278
+ * [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
280
279
 
281
280
  ## Contributing
282
281
 
Binary file
Binary file
Binary file
Binary file
metadata CHANGED
@@ -1,14 +1,15 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: concurrent-ruby-ext
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.9.2
4
+ version: 1.0.0.pre1
5
5
  platform: x86-mingw32
6
6
  authors:
7
7
  - Jerry D'Antonio
8
+ - The Ruby Concurrency Team
8
9
  autorequire:
9
10
  bindir: bin
10
11
  cert_chain: []
11
- date: 2015-11-04 00:00:00.000000000 Z
12
+ date: 2015-08-19 00:00:00.000000000 Z
12
13
  dependencies:
13
14
  - !ruby/object:Gem::Dependency
14
15
  name: concurrent-ruby
@@ -16,18 +17,20 @@ dependencies:
16
17
  requirements:
17
18
  - - "~>"
18
19
  - !ruby/object:Gem::Version
19
- version: 0.9.2
20
+ version: 1.0.0.pre1
20
21
  type: :runtime
21
22
  prerelease: false
22
23
  version_requirements: !ruby/object:Gem::Requirement
23
24
  requirements:
24
25
  - - "~>"
25
26
  - !ruby/object:Gem::Version
26
- version: 0.9.2
27
+ version: 1.0.0.pre1
27
28
  description: |2
28
29
  C extensions to optimize the concurrent-ruby gem when running under MRI.
29
30
  Please see http://concurrent-ruby.com for more information.
30
- email: jerry.dantonio@gmail.com
31
+ email:
32
+ - jerry.dantonio@gmail.com
33
+ - concurrent-ruby@googlegroups.com
31
34
  executables: []
32
35
  extensions: []
33
36
  extra_rdoc_files:
@@ -70,9 +73,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
70
73
  version: 1.9.3
71
74
  required_rubygems_version: !ruby/object:Gem::Requirement
72
75
  requirements:
73
- - - ">="
76
+ - - ">"
74
77
  - !ruby/object:Gem::Version
75
- version: '0'
78
+ version: 1.3.1
76
79
  requirements: []
77
80
  rubyforge_project:
78
81
  rubygems_version: 2.4.8