Getting All Entries from a cache

Question

Hi Folks,
     Just a small interesting observation. In an attempt to get back all the data from my partitioned cache I tried the following approaches:
     //EntrySet
     NamedCache cache = NamedCache.getCache("MyCache");
     Iterator<Entry<MyKeyObj, MyObj>> iter = cache.entrySet().iterator();
     //iterator over objects and get values
     //KeySet & getAll
     NamedCache cache = NamedCache.getCache("MyCache");
     Map results = cache.getAll(cache.keySet());
     Iterator<Entry<MyKeyObj, MyObj>> iter = results.iterator();
     //iterate over objects and get values
     Retrieving ~47k objects from 4 nodes takes 21 seconds using the entryset approach and 10 seconds for the keyset/getal approach.
     does that sound right to you? That implies that the entryset iterator is lazy loaded using get(key) for each entry.
     Regards,
     Max

Answer 1

Hi Gene,
     I actually posted the question, because we are currently performance-tuning our application, and there are scenarios where (due to having a large amount of badly organized legacy code with the bottom layers ported to Coherence) there are lots of invocations getting all the entries from some caches, sometimes even hundreds of times during the processing of a HTTP request.
     In some cases (typically with caches having a low cache-size) we found, that the entrySet-AlwaysFilter solution was way faster than the keyset-getall solution, which was about as fast as the solution iterating over the cache (new HashMap(cache)).
     I just wanted to ask if there are some rules of thumb on how long is it efficient to use the AlwaysFilter on distributed caches, and where it starts to be better to use the keyset-getall approach (from a naive test-case keyset-getall seemed to be better upwards from a couple-of-thousand entries).
     Also, as we are considering to move some of the caches (static data mostly, with usually less than 1000 entries, sometimes even as few as a dozen entries in a named cache, and in very few cases as many as 40000 entries) to a replicated topology, that is why I asked about the effect of using replicated caches...
     I expect the entrySet-AlwaysFilter to be slower than the iterating solution, since it effectively does the same, and also has some additional filter evaluation to be done.
     The keySet-getall will be something similar to the iterating solution, I guess.
     What is to be known about the implementation of the values() method?
     Can it be worth using in some cases? Does it give us an instant snapshot in case of replicated caches? Is it faster than the entrySet(void) in case of replicated caches?
     Thanks and best regards,
     Robert