Renamed actor groups

Author: vaclav

grails-doc/src/guide/2.4 What's new.gdoc

@@ -27,6 +27,9 @@ h4. Renaming hints
 * withAsynchronizer() -> withPool()
 * withExistingAsynchronizer() -> withExistingPool()
 * orchestrate() -> runForkJoin()
+* ActorGroup -> PGroup
+* PooledActorGroup -> DefaultPGroup
+* NonDaemonActorGroup -> NonDaemonPGroup
 
 h3. Fork / Join
 

grails-doc/src/guide/5.1 Actors Principles.gdoc

@@ -115,7 +115,7 @@ A little bit more realistic example of an event-driven actor that receives two n
 import static groovyx.gpars.actor.Actors.*
 
 //not necessary, just showing that a single-threaded pool can still handle multiple actors
-defaultPooledActorGroup.resize 1
+defaultActorPGroup.resize 1
 
 final def console = actor {
     loop {
@@ -187,7 +187,7 @@ Closure createMessageHandler(def parentActor) {
     }
 }
 
-def console = new PooledActorGroup(1).actor {
+def console = new DefaultPGroup(1).actor {
     react {
         println "Sorted array:\t${it}"
         System.exit 0
@@ -251,7 +251,7 @@ h3. Pool management
 _Actors_ can be organized into groups and as a default there's always an application-wide pooled actor group available. And just like the _Actors_ abstract factory can be used to create actors in the default group, custom groups can be used as abstract factories to create new actors instances belonging to these groups.
 
 {code}
-def myGroup = new PooledActorGroup()
+def myGroup = new DefaultPGroup()
 
 def actor1 = myGroup.actor {
 ...
@@ -265,35 +265,35 @@ def actor2 = myGroup.actor {
 The actors belonging to the same group share the *underlying thread pool* of that group. The pool by default contains *n + 1 threads*, where *n* stands for the number of *CPUs* detected by the JVM. The *pool size* can be set *explicitly* either by setting the _gpars.poolsize_ system property or individually for each actor group by specifying the appropriate constructor parameter.
 
 {code}
-def myGroup = new PooledActorGroup(10)  //the pool will contain 10 threads
+def myGroup = new DefaultPGroup(10)  //the pool will contain 10 threads
 {code}
 
-The thread pool can be manipulated through the appropriate _PooledActorGroup_ class, which *delegates* to the _Pool_ interface of the thread pool. For example, the _resize()_ method allows you to change the pool size any time and the _resetDefaultSize()_ sets it back to the default value. The _shutdown()_ method can be called when you need to safely finish all tasks, destroy the pool and stop all the threads in order to exit JVM in an organized manner.
+The thread pool can be manipulated through the appropriate _DefaultPGroup_ class, which *delegates* to the _Pool_ interface of the thread pool. For example, the _resize()_ method allows you to change the pool size any time and the _resetDefaultSize()_ sets it back to the default value. The _shutdown()_ method can be called when you need to safely finish all tasks, destroy the pool and stop all the threads in order to exit JVM in an organized manner.
 
 {code}
 ... (n+1 threads in the default pool after startup)
 
-Actors.defaultPooledActorGroup.resize 1  //use one-thread pool
+Actors.defaultActorPGroup.resize 1  //use one-thread pool
 
 ... (1 thread in the pool)
 
-Actors.defaultPooledActorGroup.resetDefaultSize()
+Actors.defaultActorPGroup.resetDefaultSize()
 
 ... (n+1 threads in the pool)
 
-Actors.defaultPooledActorGroup.shutdown()
+Actors.defaultActorPGroup.shutdown()
 {code}
 
-As an alternative to the _PooledActorGroup_, which creates a pool of daemon threads, the _NonDaemonActorGroup_ class can be used when non-daemon threads are required.
+As an alternative to the _DefaultPGroup_, which creates a pool of daemon threads, the _NonDaemonPGroup_ class can be used when non-daemon threads are required.
 
 {code}
-def daemonGroup = new PooledActorGroup()
+def daemonGroup = new DefaultPGroup()
 
 def actor1 = daemonGroup.actor {
 ...
 }
 
-def nonDaemonGroup = new NonDaemonActorGroup()
+def nonDaemonGroup = new NonDaemonPGroup()
 
 def actor2 = nonDaemonGroup.actor {
 ...
@@ -311,8 +311,8 @@ class MyActor {
 Actors belonging to the same group share the *underlying thread pool*. With pooled actor groups you can split your actors to leverage multiple thread pools of different sizes and so assign resources to different components of your system and tune their performance.
 
 {code}
-def coreActors = new NonDaemonActorGroup(5)  //5 non-daemon threads pool
-def helperActors = new PooledActorGroup(1)  //1 daemon thread pool
+def coreActors = new NonDaemonPGroup(5)  //5 non-daemon threads pool
+def helperActors = new DefaultPGroup(1)  //1 daemon thread pool
 
 def priceCalculator = coreActors.actor {
 ...
@@ -342,15 +342,15 @@ Do not forget to shutdown custom pooled actor groups, once you no longer need th
 h3. Common trap: App terminates while actors do not receive messages
 
 Most likely you're using daemon threads and pools, which is the default setting, and your main thread finishes. Calling _actor.join()_ on any, some or all of your actors would block the main thread until the actor terminates and thus keep all your actors running.
-Alternatively use instances of _NonDaemonActorGroup_ and assign some of your actors to these groups.
+Alternatively use instances of _NonDaemonPGroup_ and assign some of your actors to these groups.
 {code}
-def nonDaemonGroup = new NonDaemonActorGroup()
+def nonDaemonGroup = new NonDaemonPGroup()
 def myActor = nonDaemonGroup.actor {...}
 {code}
 
 alternatively
 {code}
-def nonDaemonGroup = new NonDaemonActorGroup()
+def nonDaemonGroup = new NonDaemonPGroup()
 
 class MyActor extends AbstractPooledActor {
     def MyActor() {

grails-doc/src/guide/5.2 Special Actors.gdoc

@@ -80,12 +80,12 @@ final def actor = new MyActor({
 
 h3. Reactive Actor
 
-The _ReactiveActor_ class, constructed typically by calling _Actors.reactor()_ or _PooledActorGroup.reactor()_, allow for more event-driven like approach. When a reactive actor receives a message, the supplied block of code, which makes up the reactive actor's body, is run with the message as a parameter. The result returned from the code is sent in reply.
+The _ReactiveActor_ class, constructed typically by calling _Actors.reactor()_ or _DefaultPGroup.reactor()_, allow for more event-driven like approach. When a reactive actor receives a message, the supplied block of code, which makes up the reactive actor's body, is run with the message as a parameter. The result returned from the code is sent in reply.
 
 {code}
-import groovyx.gpars.actor.PooledActorGroup
+import groovyx.gpars.actor.DefaultPGroup
 
-final def group = new PooledActorGroup()
+final def group = new DefaultPGroup()
 
 final def doubler = group.reactor {
     2 * it

grails-doc/src/guide/5.4 Classic Examples using Actors.gdoc

@@ -11,11 +11,11 @@ h2. Sleeping Barber
 
 "Problem description":http://en.wikipedia.org/wiki/Sleeping_barber_problem
 
-{code}import groovyx.gpars.actor.PooledActorGroup
+{code}import groovyx.gpars.actor.DefaultPGroup
 import groovyx.gpars.actor.AbstractPooledActor
 import groovyx.gpars.actor.Actor
 
-final def group = new PooledActorGroup()
+final def group = new DefaultPGroup()
 
 final def barber = group.actor {
     final def random = new Random()
@@ -127,7 +127,7 @@ h2. Dining Philosophers
 {code}import groovyx.gpars.actor.AbstractPooledActor
 import groovyx.gpars.actor.Actors
 
-Actors.defaultPooledActorGroup.resize 5
+Actors.defaultActorPGroup.resize 5
 
 final class Philosopher extends AbstractPooledActor {
     private Random random = new Random()

grails-doc/src/guide/6. Safe.gdoc

@@ -140,14 +140,14 @@ To create a Safe instance belonging to a group, call the _safe()_ factory method
 and tune performance of agents.
 
 {code}
-final def group = new NonDaemonActorGroup(5)  //create a group around a thread pool
+final def group = new NonDaemonPGroup(5)  //create a group around a thread pool
 def jugMembers = group.safe(['Me'])  //add Me
 {code}
 
 {note:Title=Custom thread pools for agents}
 The default thread pool for agents contains daemon threads. Make sure that your custom thread pools either use daemon threads, too, which can be achieved
-either by using PooledActorGroup or by providing your own thread factory to a thread pool constructor,
-or in case your thread pools use non-daemon threads, such as when using the NonDaemonActorGroup group class, make sure you shutdown the group or the thread pool explicitly by calling its shutdown() method,
+either by using DefaultPGroup or by providing your own thread factory to a thread pool constructor,
+or in case your thread pools use non-daemon threads, such as when using the NonDaemonPGroup group class, make sure you shutdown the group or the thread pool explicitly by calling its shutdown() method,
 otherwise your applications will not exit.
 {note}
 

grails-doc/src/guide/7.1 Dataflow tasks.gdoc

@@ -56,9 +56,9 @@ Dataflow tasks can be organized into groups to allow for performance fine-tuning
 to create tasks attached to the groups.
 
 {code}
-import groovyx.gpars.actor.PooledActorGroup
+import groovyx.gpars.actor.DefaultPGroup
 
-def group = new PooledActorGroup()
+def group = new DefaultPGroup()
 
 group.with {
     task {
@@ -74,8 +74,8 @@ group.with {
 {note:Title=Custom thread pools for dataflow}
 The default thread pool for dataflow tasks contains non-daemon threads, which means your application will not exit before all tasks complete.
 When grouping tasks, make sure that your custom thread pools either use daemon threads, too, which can be achieved by
-using PooledActorGroup or by providing your own thread factory to a thread pool constructor,
-or in case your thread pools use non-daemon threads, such as when using the NonDaemonActorGroup group class, make sure you shutdown the group or the thread pool explicitly by calling its shutdown() method,
+using DefaultPGroup or by providing your own thread factory to a thread pool constructor,
+or in case your thread pools use non-daemon threads, such as when using the NonDaemonPGroup group class, make sure you shutdown the group or the thread pool explicitly by calling its shutdown() method,
 otherwise your applications will not exit.
 {note}
 

grails-doc/src/guide/7.2 Dataflow operators.gdoc

@@ -86,9 +86,9 @@ Dataflow operators can be organized into groups to allow for performance fine-tu
 to create tasks attached to the groups.
 
 {code}
-import groovyx.gpars.actor.PooledActorGroup
+import groovyx.gpars.actor.DefaultPGroup
 
-def group = new PooledActorGroup()
+def group = new DefaultPGroup()
 
 group.with {
     operator(inputs: [a, b, c], outputs: [d]) {x, y, z ->
@@ -101,7 +101,7 @@ group.with {
 {note:Title=Custom thread pools for dataflow}
 The default thread pool for dataflow operators contains non-daemon threads, which means your application will not exit before all operators are stopped.
 When grouping operators, make sure that your custom thread pools either use daemon threads, too, which can be achieved by
-using PooledActorGroup or by providing your own thread factory to a thread pool constructor,
-or in case your thread pools use non-daemon threads, such as when using the NonDaemonActorGroup group class, make sure you shutdown the group or the thread pool explicitly by calling its shutdown() method,
+using DefaultPGroup or by providing your own thread factory to a thread pool constructor,
+or in case your thread pools use non-daemon threads, such as when using the NonDaemonPGroup group class, make sure you shutdown the group or the thread pool explicitly by calling its shutdown() method,
 otherwise your applications will not exit.
 {note}

grails-doc/src/guide/7.3 Dataflow implementation.gdoc

@@ -1,5 +1,5 @@
 The Dataflow Concurrency in GPars builds on top of its actor support. All of the dataflow tasks share a thread pool and so the number threads created through _DataFlow.task()_ factory method don't need to correspond to the number of physical threads required from the system.
-The _DataFlow.task()_ factory method takes an optional actorGroup parameter to specify a group to which the task should belong. Since each group defines its own thread pool, you can easily organize tasks around different thread pools just like you do with actors.
+The _PGroup.task()_ factory method can be used to attach the created task to a group. Since each group defines its own thread pool, you can easily organize tasks around different thread pools just like you do with actors.
 
 h3. Combining actors and Dataflow Concurrency
 

grails-doc/src/ref/Actors/Usage.gdoc

@@ -52,8 +52,8 @@ me.join()
 
 h3. Actor groups
 {code}
-def coreActors = new NonDaemonActorGroup(5)  //5 non-daemon threads pool
-def helperActors = new PooledActorGroup(1)  //1 daemon thread pool
+def coreActors = new NonDaemonPGroup(5)  //5 non-daemon threads pool
+def helperActors = new DefaultPGroup(1)  //1 daemon thread pool
 
 def priceCalculator = coreActors.actor {
 ...

src/main/groovy/groovyx/gpars/Definitions.gdsl

@@ -61,7 +61,7 @@ contributor(actorBody) {
         def currentMethod = call.bind()
         def clazz = currentMethod?.containingClass
         final def clazzName = clazz?.qualName?.toUpperCase()
-        if ((clazzName?.contains("ACTORGROUP")) || (clazzName?.contains("ACTORS"))) {
+        if ((clazzName?.contains("PGROUP")) || (clazzName?.contains("ACTORS"))) {
             method name: "react", type: "void", params: [closure: 'groovy.lang.Closure']
             method name: "react", type: "void", params: [timeout: 'long', unit: 'java.util.concurrent.TimeUnit', closure: 'groovy.lang.Closure']
             method name: "react", type: "void", params: [timeout: 'groovy.time.Duration', closure: 'groovy.lang.Closure']

src/main/groovy/groovyx/gpars/actor/AbstractPooledActor.java

@@ -34,8 +34,8 @@
  * AbstractPooledActor provides the default Actor implementation. It represents a standalone active object (actor),
  * which reacts asynchronously to messages sent to it from outside through the send() method.
  * Each Actor has its own message queue and a thread pool shared with other Actors by means of an instance
- * of the ActorGroup, which they have in common.
- * The ActorGroup instance is responsible for the pool creation, management and shutdown.
+ * of the PGroup, which they have in common.
+ * The PGroup instance is responsible for the pool creation, management and shutdown.
  * All work performed by an Actor is divided into chunks, which are sequentially submitted as independent tasks
  * to the thread pool for processing.
  * Whenever an Actor looks for a new message through the react() method, the actor gets detached

src/main/groovy/groovyx/gpars/actor/ActorGroup.groovy

@@ -27,7 +27,7 @@ import groovyx.gpars.scheduler.Pool
  * @author Vaclav Pech, Alex Tkachman
  * Date: May 8, 2009
  */
-public abstract class ActorGroup {
+public abstract class PGroup {
 
     /**
      * Stores the group actors' thread pool
@@ -37,9 +37,9 @@ public abstract class ActorGroup {
     public Pool getThreadPool() { return threadPool; }
 
     /**
-     * Creates a group of pooled actors. The actors will share a common daemon thread pool.
+     * Creates a group for actors, agents, tasks and operators. The actors will share a common daemon thread pool.
      */
-    protected def ActorGroup(final Pool threadPool) {
+    protected def PGroup(final Pool threadPool) {
         this.threadPool = threadPool
     }
 

src/main/groovy/groovyx/gpars/actor/Actors.groovy

@@ -24,7 +24,7 @@ import groovyx.gpars.scheduler.ResizeablePool
  * <pre>
  * import static org.gpars.actor.Actors.*
  *
- * Actors.defaultPooledActorGroup.resize 1
+ * Actors.defaultActorPGroup.resize 1
  *
  * def actor = actor {*     react {message ->
  *         println message
@@ -36,7 +36,7 @@ import groovyx.gpars.scheduler.ResizeablePool
  *
  * All actors created through the Actors class will belong to the same default actor group and run
  * on daemon threads.
- * The PooledActorGroup class should be used when actors need to be grouped into multiple groups or when non-daemon
+ * The DefaultPGroup class should be used when actors need to be grouped into multiple groups or when non-daemon
  * threads are to be used.
  * @author Vaclav Pech, Alex Tkachman
  * Date: Feb 18, 2009
@@ -46,7 +46,7 @@ public abstract class Actors {
     /**
      * The default actor group to share by all actors created through the Actors class.
      */
-    public final static PooledActorGroup defaultPooledActorGroup = new PooledActorGroup(new ResizeablePool(true))
+    public final static DefaultPGroup defaultActorPGroup = new DefaultPGroup(new ResizeablePool(true))
 
     /**
      * Creates a new instance of PooledActor, using the passed-in closure as the body of the actor's act() method.
@@ -55,7 +55,7 @@ public abstract class Actors {
      * @return A newly created instance of the AbstractPooledActor class
      */
     public static AbstractPooledActor actor(Runnable handler) {
-        return defaultPooledActorGroup.actor(handler)
+        return defaultActorPGroup.actor(handler)
     }
 
     /**
@@ -67,14 +67,14 @@ public abstract class Actors {
      * @return A new instance of ReactiveEventBasedThread
      */
     public static AbstractPooledActor reactor(final Closure code) {
-        return defaultPooledActorGroup.reactor(code)
+        return defaultActorPGroup.reactor(code)
     }
 
     /**
      * Creates an instance of DynamicDispatchActor.
      * @param code The closure specifying individual message handlers.
      */
     public static AbstractPooledActor messageHandler(final Closure code) {
-        return defaultPooledActorGroup.messageHandler(code)
+        return defaultActorPGroup.messageHandler(code)
     }
 }

src/main/groovy/groovyx/gpars/actor/DefaultPGroup.groovy

@@ -41,7 +41,7 @@ import groovyx.gpars.scheduler.Pool
  * </pre>
  *
  * Otherwise, if constructing Actors directly through their constructors, the AbstractPooledActor.actorGroup property,
- * which defaults to the Actors.defaultPooledPGroup, can be set before the actor is started.
+ * which defaults to the Actors.defaultActorPGroup, can be set before the actor is started.
  *
  * <pre>
  * def group = new DefaultPGroup()
@@ -60,21 +60,22 @@ import groovyx.gpars.scheduler.Pool
 public final class DefaultPGroup extends PGroup {
 
     /**
-     * Creates a group of pooled actors. The actors will share a common daemon thread pool.
+     * Creates a group for actors, agents, tasks and operators. The actors will share the supplied thread pool.
+     * @param threadPool The thread pool to use for the group
      */
     public def DefaultPGroup(final Pool threadPool) {
         super(threadPool)
     }
 
     /**
-     * Creates a group of pooled actors. The actors will share a common daemon thread pool.
+     * Creates a group for actors, agents, tasks and operators. The actors will share a common daemon thread pool.
      */
     def DefaultPGroup() {
         super(new DefaultPool(true))
     }
 
     /**
-     * Creates a group of pooled actors. The actors will share a common daemon thread pool.
+     * Creates a group for actors, agents, tasks and operators. The actors will share a common daemon thread pool.
      * @param poolSize The initial size of the underlying thread pool
      */
     def DefaultPGroup(final int poolSize) {