During invokeAll() execution coherence calls both applyIndex and evaluateEntry methods

Question

There is an an odd behaviour of invokeAll(Filter filter,...) method, because both applyIndex() and evaluateEntry() (for retained entries) are called during invocation.
I don't understand why coherence calls evaluateEntry() method when a set is already filtered by using indices, since it is redundant operation which could decrease performance.
Also such behaviour causes problems with InKeySetFilter, because the underlying set contains binary keys, but evaluateEntry() receives "plain" entry and returns false:
cache.invokeAll(new InKeySetFilter(AlwaysFilter.INSTANCE, cache.keySet()), new ExtractorProcessor(new IdentityExtractor()));
//returns no items
alertCache.keySet(new InKeySetFilter(AlwaysFilter.INSTANCE, alertCache.keySet()));
//but this call returns all items
Can someone explain such behaviour and advice any solution or workaround?
PS Coherence 3.5.3
Edited by: Serge Vinogradov on 23-Aug-2010 08:43
Edited by: Serge Vinogradov on 23-Aug-2010 08:45

Answer 1

Serge Vinogradov wrote:
Robert,
both this methods were actually called during invokeAll execution (checked it with debugger) and applyIndex returned null.
But I've found another calls of evaluateEntry at DistributedCache.onInvokeFilterRequest. Let me quote an extract from it:
public void onInvokeFilterRequest(InvokeFilterRequest msgRequest)
Object aEntry[] = null;
aEntry = storage.query(filter, Storage.QUERY_INVOKE, partMask);
...//iterate entris
Storage.BinaryEntry entry = (Storage.BinaryEntry)aEntry[iR];
if((filter != null) ? InvocableMapHelper.evaluateEntry(filter, entry) : true)
entry.ensureWriteable();
} else
unlockKey(storage, binKey, false);
aEntry[iR] = null;
cEntries--;
continue;
...//then process not null entries
As you can see InvocableMapHelper.evaluateEntry uses original filter, but not the filter returned after appliyng index. As I understand it is done for correct dealing with locking and to ensure that entry is still complied with filter.
We have overridden InKeySetFilter class as a workaround:
public class FixedInKeySetFilter extends InKeySetFilter {
private transient boolean isFiltered = false;
public FixedInKeySetFilter() {
super();
public FixedInKeySetFilter(Filter filter, Set set) {
super(filter, set);
public Filter applyIndex(Map mapIndexes, Set setKeys)
Filter resFilter = super.applyIndex(mapIndexes, setKeys);
isFiltered = (resFilter == null);
return resFilter;
@Override
public boolean evaluateEntry(Map.Entry entry) {
return isFiltered || super.evaluateEntry(entry);
Edited by: Serge Vinogradov on 24-Aug-2010 08:33Hi Serge,
you are right... I did not expect the code to intentionally lose the returned filter reference, but that clearly seems to be the case here...
On the other hand, your evaluateEntry implementation does not seem to be correct as it does not delegate to a non-index-aware delegate filter...
The following implementation should probably fix all problems listed so far:
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import com.tangosol.util.Converter;
import com.tangosol.util.Filter;
import com.tangosol.util.InvocableMapHelper;
import com.tangosol.util.filter.InKeySetFilter;
import com.tangosol.util.filter.IndexAwareFilter;
public class FixedInKeySetFilter extends InKeySetFilter {
     private transient boolean isConverted;
     private transient boolean filtered;
     public FixedInKeySetFilter() {
     public FixedInKeySetFilter(Filter filter, Set setKeys) {
          super(filter, setKeys);
     @Override
     public synchronized void ensureConverted(Converter keyToInternalConverter) {
          super.ensureConverted(keyToInternalConverter);
          this.isConverted = true;
     @Override
     public Filter applyIndex(Map mapIndexes, Set setKeys) {
          if (setKeys.isEmpty()) {
               return null;
          if (!isConverted) {
               Converter converter = getKeyToInternalConverterOurself();
               if (converter != null) {
                    ensureConverted(converter);
               } else {
                    return this;
          Filter filter = getFilter();
          Filter res = super.applyIndex(mapIndexes, setKeys);
          res = setKeys.isEmpty() ? null : filter instanceof IndexAwareFilter ? res : filter;
          filtered = res == null;
          return res;
     @Override
     public boolean evaluateEntry(Entry entry) {
          if (filtered) {
               return true;
          Filter filter = getFilter();
          if (isConverted) {
               // apply index is surely invoked this case, so need not consult local setKeys...
               return InvocableMapHelper.evaluateEntry(filter, entry);
          } else {
               return super.evaluateEntry(entry);
      * Override this method if we can acquire the key-to-internal converter, e.g.
      * if we acquired it from the backing map manager context using the service name.
      * @return the key to internal converter of the cache service of the cache we are querying.
     protected Converter getKeyToInternalConverterOurself() {
          return null;
}Best regards,
Robert
Edited by: robvarga on Aug 24, 2010 11:35 PM