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.