Excessive aggregator calls?

Question

We’ve seen excessive calls to the init, process and finalizeResults. As an example, given a simple test aggregator, extending the AbstractAggregator, with one value in the (distributed) cache (with code below), this is that we see printed when running with only one default node:
Line 1: Agg instance 0, constructor with extractor
Line 2: Agg instance 0, getParallelAggregator
Line 3: Agg instance 0, init, isFinal = false
Line 4: Agg instance 0, finalizeResult, isFinal = false
Line 5: Agg instance 0, init, isFinal = false
Line 6: Agg instance 0, process, value = v1, isFinal = false
Line 7: Agg instance 0, finalizeResult, isFinal = false
Line 8: Agg instance 0, init, isFinal = true
Line 9: Agg instance 0, process, value = otherValue, isFinal = true
Line 10: Agg instance 0, process, value = otherValue, isFinal = true
Line 11: Agg instance 0, finalizeResult, isFinal = true
So line 1 and 2 are as expected where the aggregator is created and Coherence asks for the parallel reference.
But then on line 3 and 4 an empty set is obviously given as there is only a call to the init and finalizeResult methods (with isFinal = false). Only at lines 5, 6, and 7 is where the actual first round of parallel aggregation occurs, with our “v1” value being passed in to process.
We also see at line 8 till 11 that the unnecessary empty set being passed in (at line 3 and 4) and the resulting partial event returned by finalizeResult on line 4 is being used during the reduction phase.
Aggregator code:
package com.test;
import java.util.concurrent.atomic.AtomicInteger;
import com.tangosol.util.InvocableMap.EntryAggregator;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.aggregator.AbstractAggregator;
public class TestAggregator extends AbstractAggregator {
     private static final long serialVersionUID = 9073556452395065667L;
     private static final AtomicInteger counter = new AtomicInteger();
     private transient int aggInstance;
     public TestAggregator() {
          super();
          aggInstance = counter.getAndIncrement();
          System.out.println("Agg instance " + aggInstance + ", constructor");
     public TestAggregator(ValueExtractor extractor) {
          super(extractor);
          aggInstance = counter.getAndIncrement();
          System.out.println("Agg instance " + aggInstance + ", constructor with extractor");
     @Override
     public EntryAggregator getParallelAggregator() {
          System.out.println("Agg instance " + aggInstance + ", getParallelAggregator");
          return super.getParallelAggregator();
     @Override
     protected void init(boolean isFinal) {
          System.out.println("Agg instance " + aggInstance + ", init, isFinal = " + isFinal);
     @Override
     protected void process(Object value, boolean isFinal) {
          System.out.println("Agg instance " + aggInstance + ", process, value = " + value + ", isFinal = " + isFinal);
     @Override
     protected Object finalizeResult(boolean isFinal) {
          System.out.println("Agg instance " + aggInstance + ", finalizeResult, isFinal = " + isFinal);
          if (isFinal) return "finalValue";
          else return "otherValue";
Calling code:
package com.test;
import com.tangosol.net.CacheFactory;
import com.tangosol.net.NamedCache;
import com.tangosol.util.extractor.ReflectionExtractor;
import com.tangosol.util.filter.AlwaysFilter;
public class RunTestAggregator {
     public static void main(String... args) {
          NamedCache myCache = CacheFactory.getCache("my-cache");
          myCache.put("key1", new CacheObject("v1"));
          TestAggregator aggregator = new TestAggregator(new ReflectionExtractor("getValue"));
          myCache.aggregate(AlwaysFilter.INSTANCE, aggregator);
CacheObject:
package com.test;
import java.io.Serializable;
public class CacheObject implements Serializable {
     private static final long serialVersionUID = 2915772817883073850L;
     private String value;
     public CacheObject() {}
     public CacheObject(String value) {
          this.value = value;
     * @return the value
     public String getValue() {
          return value;
     * @param value the value to set
     public void setValue(String value) {
          this.value = value;
     @Override
     public int hashCode() {
          final int prime = 31;
          int result = 1;
          result = prime * result + ((value == null) ? 0 : value.hashCode());
          return result;
     @Override
     public boolean equals(Object obj) {
          if (this == obj)
               return true;
          if (obj == null)
               return false;
          if (getClass() != obj.getClass())
               return false;
          CacheObject other = (CacheObject) obj;
          if (value == null) {
               if (other.value != null)
                    return false;
          } else if (!value.equals(other.value))
               return false;
          return true;
}

Answer 1

BigAndy wrote:
Hi cfelde / JK,
I'm seeing similar behaviour: calls with empty sets. I'm not convinced its the partition issue you mention jk as I'm firing the aggregator against a key collection with only a single key in it. I'd assumed that the call to aggregate with an empty set was a special undocumented 'you should initialise now' call, (I'm not deriving from abstract agg as I need the backing map). But this didn't sit right and so I hit the forum and found this post.
If I'm firing the aggregator against a known collection of keys and not a filter I would expect only the nodes holding the key(s) to receieve the aggregator and run it, and for it to be run only against the partition/entry that matches that key(s).
This is not what I see. I'm currently running in little grid with 1storage node and as an extend client. When I get back into the office I'll try this against a full grid and see what gets logged. My gut tells me the empty aggregate call will be on the proxy on the main aggregator, not the parralel ones. I also don't think I saw the results of the empty ca passed to the aggregateResults, but that could be because I returned null from aggregate...
I'm on 3.7.1.6.Hi BigAndy,
AbstractAggregator is a bit tricky and is not really well documented in the Javadoc.
Read the corresponding section about it in the Coherence 3.5 book, it explains it in a much more understandable way.
The point is that there are three methods intended to be implemented in AbstractAggregator:
init, process, finalizeResult.
All three are dual purpose:
1. They are invoked in the above order as part of the parallel aggregation on the storage nodes, once per storage node. In this invocation fFinal is false. The process method receives extracted values (extracted from the entry with the aggregator passed to the constructor) in the object parameter, and the finalizeResult must create partial result object.
2. They are also invoked in the above order as part of aggregating the partial results on the caller node. In this invocation fFinal is true. The process method receives partial result objects (created by the finalizeResult methods invoked on the storage nodes) in the object parameter, and finalizeResult must return the final result.
Between the method invocations, you are supposed to maintain state in the attributes of the aggregator instance itself.
As for multiple invocation passes of (init+process*+finalizeResult) with fFinal being false on the same node, it is up to Coherence to decide in what groupings you are going to get the entries. It can depend on several things, among others whether you have partitioned backing maps, whether you have partitions transferred between nodes, possibly other things, and of course possible bugs.
The only thing that is guaranteed that all entries from the same partition are fed to process() during the same pass. You can probably also rely on the assumption that there is going to be only a single thread doing an init+process*+finalizeResult on any instance of an AbstractAggregator subclass (due to the intention of maintaining state in the aggregator instance).
Best regards,
Robert