GPars - Groovy Parallel Systems

1.2.1

A fix in the generated pom file to make the groovy-all dependency optional.

1.2.0
Check out the "JIRA release notes":http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=12030&version=19439

h3. Project changes

h3. Asynchronous functions

h3. Parallel collections

h3. Fork / Join

h3. Actors

* Annotated actor and actor factory methods with @DelegatesTo to enable use of actors inside statically compiled Groovy code

h3. Dataflow

* A thenForkAndJoin() method added to Promises to ease the creation of a fork/join algorithm with promises
* Lazy tasks were added to simplify creation of asynchronous activities with execution delayed until their result is actually asked for
* Annotated operator factory methods with @DelegatesTo to enable use of dataflow operators and selectors inside statically compiled Groovy code

h3. Agent

h3. Stm

h3. Other

* Replaced java.util.Timer with ScheduledExecutorService for timeout handling
* Proper shutdown of timers and thread-local variables added to the GParsConfig class


1.1.0
Check out the "JIRA release notes":https://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=12030&version=17399

h3. Project changes

h3. Asynchronous functions

h3. Parallel collections

* Deprecated foldParallel, renamed to injectParallel

h3. Fork / Join

h3. Actors

h3. Dataflow

* LazyDataflowVariable added to allow for lazy asynchronous values
* Timeout channels on Selects
* Added a Promise-based API for value selection through the Select class
* Enabled listening for bind errors on DataflowVariables
* Minor API improvement affecting Promise and DataflowReadChannel

h3. Agent

* Protecting agent's blocking methods from being called from within commands

h3. Stm

* Updated to the latest 0.7.0 GA version of Multiverse

h3. Other

* Migrated to Groovy 2.0
* Used @CompileStatic where appropriate

1.0.0
Check out the "JIRA release notes":http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=12030&version=17007

h3. Project changes

h3. Asynchronous functions

* Allowed for delayed and explicit thread pool assignment strategies for asynchronous functions
* Performance tuning to the asynchronous closure invocation mechanism

h3. Parallel collections

* Added a couple of new parallel collection processing methods to keep up with the innovation pace in Groovy
* Merged the extra166y library into GPars

h3. Fork / Join

h3. Actors

* _StaticDispatchActor_ has been added to provide easier to create and better performing alternative to _DynamicDispatchActor_
* A new method _sendAndPromise_ has been added to actors to send a message and get a promise for the future actor's reply

h3. Dataflow

* Operator and selector speed-up
* Kanban-style dataflow operator management has been added
* Chaining of Promises using the new _then()_ method
* Exception propagation and handling for Promises
* Added a DSL for easy operator pipe-lining
* Lifecycle events for operators and selectors were added
* Added support for custom error handlers
* A generic way to shutdown dataflow networks
* An shutdown poison pill with immediate or delayed effect was added
* Polished the way operators can be stopped
* Added synchronous dataflow variables and channels
* Read channels can report their length

h3. Agent

h3. Stm

h3. Other

* Removed deprecated classes and methods
* Added numerous code examples and demos
* Enhanced project documentation
* Re-styled the user guide

0.12

Check out the "JIRA release notes":http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=12030&version=16994

h3. Project changes

h3. Asynchronous functions

* The asyncFun() method now creates composable asynchronous functions
* The @AsyncFun annotation can be used to create composable asynchronous functions stored in fields in a more declarative way

h3. Parallel collections

* Collections can now repeatedly be made transparently concurrent or sequential using makeConcurrent() and makeSequential() methods
* Renamed makeTransparent() to makeConcurrent()

h3. Fork / Join

* A few new demos illustrating Fork/Join applicability to recursive functions have been added
* Leveraging the new and efficient implementation of the jsr-166y (aka Java 7) Fork/Join library
* The runChildDirectly() method allowing to mix asynchronous and synchronous child task execution

h3. Actors

* Active Objects wrapping actors with an OO facade
* Enhanced DynamicDispatchActor's API for dynamic message handler registration
* Added BlockingActor to allow for non-continuation style actors
* Removed the deprecated actor classes

h3. Dataflow

h3. Agent

h3. Stm

* Initial support for Stm through Multiverse was added

h3. Other

* Switched to the most recent Java 7 Fork/Join library to ensure compatibility with future JDKs
* Raised the Groovy level used for compilation to 1.7
* Created a pdf version of the user guide
* An update to the stand-alone maven-based Java API "demo application"
* Added numerous code examples and demos
* Enhanced project documentation

0.11

Check out the JIRA release notes at http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=12030&version=16391

h3. Project changes

See http://gpars.codehaus.org/Breaking+Changes for the list of breaking changes.

h3. Parallel collections

* Added a speculate() method to concurrently run multiple functions each representing a different path to achieve the required goal, while harvesting the first calculated result
* Added the _combine_ method into the map/reduce family of functions
* General speed-up of Parallel Array construction and execution

h3. Fork / Join

h3. Actors

* Speed-up of the actor messaging core
* Refactored Reactor and DynamicDispatchActor achieving a 15x speed-up
* Conditional and counting loop
* Changed the message timeout API
* Deprecated _AbstractPooledActor_
* Added _DefaultActor_ as a new implementation of the stateful actor principle
* Removed support for replies and senders on messages
* Extended support for senders to actors themselves
* Removed the _receive()_ from _DefaultActor_

h3. GroovyCSP

h3. Dataflow

* New specialized operators - _selector_ , _prioritySelector_ and _splitter_
* Added _select_ and _prioritySelect_ methods to select a value from multiple channels
* Dataflow tasks accept Callable as parameters on top of Closures
* Introduced dataflow queues
* Unified the interface for dataflow variables, streams and queues - _DataFlowChannel_
* Methods for atomic update to multiple operator's output channels
* Fixed issues with reusing the same parallel group in the DataFlowVariable whenBound() handlers
* Tasks can return values and can be joined
* DataFlowQueue's _whenBound_ renamed to _wheneverBound_ and _whenNextBound_ renamed to _whenBound_ to obey the _DataFlowChannel_ interface contract
* DataFlow default parallel group has been made daemon

h3. Agent

* Added listeners and validators
* Considerable speed-up

h3. Other

* Java API - GPars can now be used from Java
* A stand-alone maven-based Java API "demo application":http://bamboo.ci.codehaus.org/browse/GPARS-REL-5/artifact/GPars-Java-API-integration-demo-project/gpars-mvn-java-demo-0.11-beta-2.zip was added to show GPars integration and use from Java
* Made Groovy 1.8 compatible

h3. Renaming hints

* The _AbstractPooledActor_ class is now deprecated, use _DefaultActor_ instead
* The _DataFlowStream_ class has been renamed to _DataFlowQueue_
* The _memoize_ method family has been renamed to _gmemoize_ in order to avoid name collisions with memoize in Groovy 1.8

0.10

Check out the JIRA release notes at http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=12030&version=15793

Project changes

See http://gpars.codehaus.org/Breaking+Changes for the list of breaking changes.

Parallel collections

* Renamed the Parallelizer and Asynchronizer classes to more appropriate GParsPool and GParsExecutorsPool as well as their methods
* Enabled asynchronous closures inside the GParsPool.withPool() methods
* Reorganized the asynchronous closure invocation functionality
* Unified the GParsPool and GParsExecutorsPool functionality to eliminate the need to combine uses of the two classes
* Improved the map/reduce performance by eliminating unnecessary conversions
* Seed values are now allowed for fold() and reduce() methods
* Added findAnyParallel() and countParallel() methods

Fork / Join

* Simplified API to define Fork/Join calculation without the need to create explicit subclasses

Actors

* Restructured actor grouping in order to unify it with agent and dataflow task grouping
* The implicit _call()_ method can be used to send messages

GroovyCSP

* Added a JCSP-wrapping CSP implementation

Dataflow

* A _maxForks_ flag has been added to allow Dataflow operators to internally work concurrently
* Added support for grouping operators and tasks around shared thread pools

Safe

* Reimplemented to increase performance
* Added support for grouping Safe instances around shared thread pools
* Added agent error handling capabilities
* Renamed to *Agent*
* The implicit _call()_ method can be used to update the agent

Other

* Dependency on Jetty has been made optional
* Automated upload of downloadable artifacts
* OSGi support for the GPars jar

0.9

Check out the JIRA release notes at http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=12030&version=15702

Project changes

* Moved to Codehaus - http://gpars.codehaus.org
* Provided a User Guide - http://www.gpars.org/guide/index.html
* Changed the package structure
* Fully built using Gradle
* Continually built on JetBrains public TeamCity site (http://teamcity.jetbrains.com/) and on Codehaus Bamboo (http://bamboo.ci.codehaus.org/browse/GPARS-DEF)
* Experimental OSGi support

Parallel collections

* Map/Reduce
* Transparently parallel methods added allowing to change the sequential semantics of the usual each(), collect() and such methods to a concurrent one
* Parallel methods renamed from xxxAsync to xxxParallel to better capture the nature of the methods. E. g. eachAsync() is now eachParallel().
* New parallel methods added - groupByParallel(), minParallel(), maxParallel(), sumParallel(), foldParallel(), grepParallel()
* The allParallel() method renamed to everyParallel()
* The withParallelizer() and withAsynchronizer() methods have been renamed to doParallel()

Actors

* No need to start actors explicitly after calling the _actor()_ factory method
* Enabled receive() for blocking message read in event-driven actors
* Removed thread-bound actors
* Created a DSL to add message handlers to DynamicDispatchActor at construction time
* The sendAndContinue() method
* Performance improvements
* Reorganized daemon and non-daemon actor groups
* Resizeable thread-pool used by the default actor group
* Modified the reply mechanism
* The message sender property has been added to messages

Dataflow

* Lightweight Dataflow Tasks added
* Full-blown Dataflow Operators created
* The DataFlows class added to provide a convenient container for dataflow variables indexed by either a name or a number
* Bound handlers through the >> operator - register closures, which will get invoked once the dataflow variable gets bound to a value

Safe

* An await() method added to allow callers to synchronize with the agent
* Higher reader priority supported

Other

* Levering GroovyDSL API in IntelliJ IDEA to get IDE support for GPars DSLs
* Added Fork / Join convenience abstraction for hierarchical (divide and conquer) tasks

0.8.4
DataFlows
Improved Gradle build
Maintenance

0.8.3
Enabled Gradle builds
Uploaded into a maven repository

0.8.2
Updated for groovy 1.6.4
Added the await() method to the SafeVariable class
Added the instantVal property to the SafeVariable class to prioritize read requests

0.8.1
Added SafeVariable
Migrated DataFlowQueue to Java
Fixed problem with nested actor creation closures
Added short-hand methods for concurrent collection processing to Asynchronizer and Parallelizer

0.8
Added DataFlow concurrency support
Added sendAndWait() methods to actors to block the caller until a reply arrives
Added an experimental option to use the JSR-166y ForkJoin pool for actors
Enabled thread-bound actors to reuse threads from a resizeable common pool
Added AsyncEnhancer and ParallelEnhancer classes enabling asynchronous collection processing through meta-class enhancements
Restructured actor groups with respect to the thread-bound actor thread reuse and Fork/Join pool support
Supported @Immutable for messages
Ability to join actors to await their termination
Ability to suspend actor and message enhancements for replies, which has impact on message delivery speed
Restructured actor classes to increase code reuse
Removed the beforeStop() lifecycle method from actors
Fixed the event-driven actor's loop, when no react is called
DynamicDispatchActor added to allow for an alternative message handling syntax - dynamic method dispatch to multiple onMessage() methods
Added a Reactor implementation - a special purpose actor, which after receiving a message runs its body with the message as a parameter and the result of the code is send in reply.
Several performance benchmarks included
Minor performance optimizations
Bugfixing

0.7
Reply methods for thread-bound actors
Reply methods available on received messages
Ability to send replies between thread-bound and event-driven actors in both directions
Documented structuring actors code and implementing event-driven loops
Overloaded the << operator to perform send
Handling multiple messages in single receive/react
Actor groups, multiple independent configurable thread pools
Gradle build script 

0.6
Event-driven (pooled) actors

0.5
Mixin support
The act() method wrapped with TimeCategory to allow for time DSL in receive() calls

0.4
Actors added

0.3
Set default pool size to Ncpu + 1, where Ncpu is the number of CPU in the system.
Made pool threads to be non-daemon.
Updated documentation.

0.2
Enabled calling withParallelizer() and withAsynchronizer() methods on any object.

0.1
Initial release of the core functionality for both Parallelizer, which uses JSR-166y Parallel Arrays,
and Asynchronizer, which uses Java's executor services.
