I am working in a project where we due to limitations of using JDK 8 and other components used are "stuck" with Coherence CE 14 and is having a challenge where evicting entries in the local cache (part of a near cache) takes a LONG time.

I realize this is not a supported release so we are looking into solving the problem ourselves but have a specific question that could help us in this...

We are profiling and seeing that the line that seem to take a lot of time is " iterEvict.remove()" in OldCache and is marked with an issue "COH-23644" that we assume introduced the line.

Not sure if this is a reference to an issue in Coherence CE or an internal Oracle issue to the enterprise edition but either way we have not been able to find any info about it and are very curious to what the issue was and why the line was introduced...

Naively when looking at the code it seems to remove keys from an ArrayList of elements to be evicted as it is iterated - it is not clear to us WHY there is a need to do this and in general removing elements from ArrayLists is expensive (at least in the past required copying the array) so we are suspecting this could be at least one reason we see slow eviction (our caches are big and so could the list of keys to evict be)....

Our first work-around that we are testing now is to increase the low-units to be about 99% of the high-units to ensure the size of the array list will be small (then the ~O(n ** 2) effect of the repeated array.remove operation is minimized) - lets see if it works...

We are also considering, as a further work around, try using Caffeine (2.X version ) as a local cache with this Coherence CE release (using the old lower level mechanism that has been available to provide your owen cache implementation) but not sure how well it would work - are experiences of this would be welcome!

I have noticed that the above mentioned line is present also in the latest Coherence CE release so if this is the cause of the problem we are seeing it may be present also with the latest...

in particular in cloud environment (with typically 3 AZs that one at a time may experience large scale events or failures) or other situations with few large racks that one need to handle as a failure mode without data loss the memory consumption for "backup count" is significant and it would be a good option to be able to store this data on a flash based (or for instance off-heap) structure (both options for instance provided by Chronicle Map so perhaps a usable component ro base an implementation on)

I am using Coherence 24.03 and has started to look at using the gRPC prox to allow "dynamically connected clients" (AWS Lambda functions) that be members of a Coherence cluster and client written in other languages than Java.

As we already have a large "near cache" (local front and partitioned back) that is central to our system I would the new clients to also use it rather than create a new cache for use with gRPC.

I always struggle with how to write the XML cache configuration for my systems and this is no exception - can anybody please give me some hints if this is possible and if so how I could go about it?

There is a small error in the example and the referenced source code in Import Declarations section.

dev-guidelines says,

All import statements should be sorted alphabetically.

though the example shown and the respective source file has wrong ordering

import com.oracle.coherence.common.base.Exceptions;
import com.oracle.coherence.common.base.Hasher;
import com.oracle.coherence.common.base.HashHelper;
import com.oracle.coherence.common.base.Formatting;
import com.oracle.coherence.common.base.Objects;

A need some general advice on how Indexes work from a consistency and backup point of view? Lets say I update some data spread over multiple partitions using an entry processor - when are the indexes updated with those changes?
Also are Coherence indexes backed up over several nodes (how many, asynch or synch...)?

I have previously reported (#95) problems with very poor performance pruning large caches due to a code line where the first element in an array list is removed in every iteration of the list resulting in a O(n ** 2) algorithm. I got the response the coherence CE team would look into the problem.

This problem is present in the class OldCache method pruneIncremental at the line "iterEvict.remove(); // COH-23644".

A better solution, in my mind, would be to just ignore removing the element as the whole structure is anyway released as garbage once the iteration ios completed. As an alternative one could iterate the list from the end as deleting the last element of an array list seem to be an optimized case (at least in later SDKs).

Due to the very slow performance of the algorithm as it is written now I doubt memory will actually be released faster with the current implementation (according to discussion on my previous report this seemed to be the motivation of introducing this line / COH-23644) compared to much faster getting through the whole structure and releasing it at the end...

I have not tested the new v14.1.1.0.13 release or verified if the iterated structure somewhere else in the code has been changed to no longer be an ArrayList (a LinkedList, is generally slower but would in this specific algorithm be better as removal of any elements is a O(1) operation) but a quick check of the source show this line to still be present and the problem probably not fixed :-(

To work around this problem we have ourselves removed the offending line and rebuilt Coherence CE for our use but would like to not having to perform this step for every release...

Type of question

Question about availability of a feature

Question

What did you do?
A clear and concise description of the steps you took (or insert a code snippet).

I would like to be able to write my own cache map implementation with Coherent community edition - is this possible?

Today there is (according to answer to a previous question) no way for a storage enabled cluster member to signal that it intends to leave the cluster and stigger re-balancing of its partitions in an safe and ordered way.

As a consequence it is a risky operation to "scale in" a coherence cluster (with the standard backup count of one we are vulnerable to data loss if a storage enabled node would fail while a node has terminated due to scale in). Having to use backup count of two is a possible work-around but results in a significant increase in memory use and reduced performance of updates...

A way to address this would be to provide a way to programatically indicate that a storage enabled node would like to leave and that this would initiate an orderly re-balancing of the partitions WHILE THE NODE IS STILL AVAILABLE to avoid data loss in the case of another node failing during the re-balancing.

Once this re-balancing is completed the node would be able to terminate and the scale-in operation completing.

Having this kind of functionality would be a big step taking coherence into the "cloud era" allowing cluters to not only scale out but also scale in to track needed capacity.

I need some general guidance on what support is available in Coherence CE for transactional update of multiple objects at the same time (in addition to what can be done with entry processors).

At one hand the documentation states that "Transaction Framework" is not included in CE on the other hand I can see that the CacheAdapter class is present in the source code?

Is the intention that you need to write your own equivalent of the old coherence-tx.rar (that is not provided with CE) or what is the intended use of CacheAdpater?

I am looking for general advice related to how Coherence routes requests - if a "non-storage enabled" node requests an object from a partitioned cache in the same cluster will the request be routed to the most optimal of the primary or backups (for instance if one of them is in the same rack as the requesting node - determined using the rack id) or will it always go to the node that is the "primary" owner" of the key no matter if that will result in a higher latency?
If this optimization exists would it be possible to configure if it also should take asynchronously updated backups (if used) into consideration (i.e. if it is ok to route requests to a possible slighly stale copy in the same rack rather than to one of the synchronously updated ones in another rack)?
If only two racks are used (or if having say three racks and using one asynchronoulsy updated backup) it would be quite sweet if this optimization existed as one then always would be routed within the same rack (unless during rebalancing).
In fact this optimization could even make "stretch clusters" spaning two data centres possible (in low update frequency use-cases) without using cluster replication (that is not available in CE)...

Is there a function to obtain hotkeys implemented

Describe the bug

CaffeineCache calculates the "weight" of individual entries at insertion time, using weigh function:

    private int weigh(Object oKey, Object oValue)
        {
        int cUnits = m_unitCalculator.calculateUnits(oKey, oValue);
        if (cUnits < 0)
            {
            throw new IllegalStateException(String.format(
                    "Negative unit (%s) for %s=%s", cUnits, oKey, oValue));
            }
        return (cUnits / m_nUnitFactor);
        }

This is problematic, because the method above returns 0 if a unit factor is larger than the number of units for a give entry, which is often the case when unit factor is used (typical values for unit factor are 2^10 and 2^20, in order to track and limit cache size in KBs or MBs). Even if the factor is smaller than the entry size, the loss of precision due to integer arithmetic at the single entry level is significant.

To Reproduce

1. Configure unit factor that is larger than the average entry size
2. Configure BINARY unit calculator
3. Add some entries to the cache
4. Observe that the getUnits method returns zero, even though there are entries in the cache

Expected behavior
getUnits methods should return the actual number of bytes consumed by all entries, divided by the unit factor.

In other words, unit factor should only be applied during final calculation for the backing map as a whole, not at the individual entry level.

Environment (please complete the following information):

• Coherence CE 22.06.1
• Java 11
• OS: any
• OS Version: n/a

In order to implement digest calculation of all binary data in a partitioned cache I started looking at the streaming aggregator and I found some aspects of it very suitable for the task.
When starting to develop with it I realized there where a few things I was not sure I had understood correctly.

Firstly I am not sure how some of the characteristics really work:

PARALLEL - felt fairly obvious and and an option I generally always want. In combination with BY_MEMBER one aggregator will run on each storage enabled node and with BY_PARTITION as many aggregators will run on each storage enabled node as there are partitions owned by them each. A question mark for me is however if it is the "instance itself" that have the characteristic that will be parallelized or its "sub aggregator" created by calling the supply method? Assuming the initial aggregator have options PARALLEL and PER_PARTITION what options should the aggregato(s) created by "supply" have? Just PARALLEL or?? Is characteristics only valid/obeyed on the initial top-level aggregator object? If not what is the effect when applied to member or partition level aggregator objects??

PRESENT_ONY is however a weird one - when would an aggregator EVER be passed non-existing entries? I do not get the meaning of this one...

RETAIN_ENTRIES is not clear for me either - in my case I will, while an instance of an digest aggregator is running be holding on to passed in entries to be able to to order them by binary key in a canonical order before feeding them into the digest calculation (so that I get the same result irrespective of data insert order to the cache or whatever that could result in different processing order between different caches with the same data). Am I then supposed to specify this characteristic? My guess is that this is to isolate the aggregator from other operations mutating the entries it hold on to - something that is not a cosern for me as I only intend this operation to be used when no mutation is going on....

Also I would like to know HOW the aggregators that are run on the members (storage enabled nodes) in the cluster are "created" - initially I assumed the "supply" method to be called to provide an aggregator instance that is then serialized, sent and executed as many times as was requested (BY_MEMBER or BY_PARTITION) but from my program behaves I am now guessing the original passed in aggregator object itself is serialized and once it is received by each "member" the "supply" method is called to create one or more "sub aggregators" or?

As I understand the documentation the operations described by the StreamingAgregator interface can logically be group as belonging in the top-level aggregator (supply, combine and finalizeResult) or the sub-aggregators (executed once per member or partition) i.e. accumulate, getPartialResult - is this right?

I would like to understand if the "accumulate" method passing in a "streamer" always will be the one that is called and the default implementation of the method calls the single entry "accumulate" method?! And how does the "aggregate" method relate to the "accumulate" ones?

Finally is it correct to say that accumulation will always be just two "levels" first a single top level aggregator and then a second tier running either once on each member or once per partition - or is it possible to create deeper architectures where one aggregator run per member that in turn specify the "PER_PARTITION" would be able to aggregate a third level of aggregators that are run one per partition?

I read somewhere that Coherence only worked with JDK8 - does this still apply or can it now work with more recent ones?

I would like to experiment with running an invocable on a cluster and added the following to the caching-schemes section of my custom cache configuration file:

<invocation-scheme>
      <scheme-name>my-invocation-service</scheme-name>
      <service-name>InvocationService</service-name>
      <autostart system-property="tangosol.coherence.invocation.autostart">true</autostart>
 </invocation-scheme>

but when I try running the code below I get the error message "No scheme found for service my-invocation-service"...

InvocationService service = (InvocationService)CacheFactory.getService
                ("my-invocation-service");

I can see from log output that Coherence is reading my cache configuration file but perhaps there is something more I need to configure in order for invocation to work or I have missread the doc on how to get hold of the service?!

Any suggestions on what I may be doing wrong is much appreciated as I right now cant see it....

Describe the bug
My application modifies the config sources for Helidon. I found that the Coherence ConfigPropertyResolver creates its own config sources and caches it locally in the class, disregarding the config sources that are later setup by my application startup code. The problem is that Coherence cannot find the system properties that I have configured, such as the cluster name and role.

To Reproduce
final var config = ... some custom config with coherence.cluster specified ...
Server.Builder serverBuilder = Server.builder().config(config);

Observe the logs, some default cluster name is used instead of what is specified in coherence.cluster

Expected behaviour
I should be able to define the coherence config using my own config sources and have it get used.

Environment (please complete the following information):

• Coherence CE version 20.06

As described already in discussion section it may for various reasons (work around to allow scale down while maintaining HA, mirror typical HA setup of cloud providers with 3 AZs, speed up get&getAll requests in 3 AZ cloud setups) be interesting to have backup count of 2 but in the event of an AZ failure it would be desirable to abandon the second backup to conserve memory.

In some older Coherence doc I have seen recommendations that it is not a good idea to run a Coherence cluster over geographically distributed sites unless 10Gbit bandwidth and "extremely low latency".

When using Cloud (at least AWS) availability zones ARE geographically distributed but using low latency dedicated fiber connections and the sites are within a limited "metro area" with the purpose to allow synchronous replication for databases and in my experience is in the "low single digit" ms latency range.

Is this considered "extremly low" from a Coherence point of view or not and is it REALLY a requirement to go as high as 10Gbit - there are after all still quite few smaller EC2 family members (VMs) and very rarely container instances that go that high - more typical EC2 figures for small instances are at best ~5Gbit or even lower and for "serverless" (=managed) containers (like ECS Fargate) less than 1Gbit sustained (burting can be much higher of course).

We have done some tests running Coherence over 3 AZs on smaller EC2 instances (max ~5Gbit) and so far it seem to have worked ok but we have not pushed the cluster that hard in performance tests yet...

An alternative that REALLY result in low latency is of course to use "placement groups" and deploy the whole cluster in one AZ (this can basically get us down to "same rack" latency level) but is MUCH less attractive from an availability point of view - when there are 3+ sufficiently geographically separated and in all imaginable ways independent sites to use you really want to take advantage of it if possible...

What experiences can others share? Are you running Coherence over multiple AZs in the cloud and if so how has it worked out??

If you don't specify a value for "low-units" (or specify 0) the value used is today calculated as 0.75 * high-units.

It would be very nice to be able to set this percentage to another value than 0.75 and in this way not having to specify an explicit calculated value for "low-units" for every cache as soon as you would like another percentage.

Perhaps there is already a parameter or method for overriding this but in that case we have failed to find it....

We are getting quite frequent warnings in our Coherence log on storage enabled nodes mentioning "initiating connection migration with tmb" and I would like some info about what it means on a more technical level and perhaps suggestions on most common causes?

I am guessing some problem on the physical network as well as long GC pauses could result in more or less any network related warning in Coherence but are there also other possible reasons and are there any tips on how to further debug the problem?

2023-03-13 20:17:56.310/95085.948 Oracle Coherence CE 14.1.1.0.12 (thread=SelectionService(channels=112, selector=MultiplexedSelector(sun.nio.ch.EPollSelectorImpl@3676ac27), id=1660451908), member=17): tmb://138.106.96.41:9001.49982 initiating connection migration with tmb://138.106.96.25:33316.40573 after 15s ack timeout health(read=false, write=true), receiptWait=Message "PartialValueResponse"
{
FromMember=Member(Id=17, Timestamp=2023-03-12 17:53:14.974, Address=138.106.96.41:9001, MachineId=46694, Location=site:sss.se.xxxxyyyy.com,machine:l4041p.sss.se.xxxxyyyy.com,process:391,member:l4041p-2, Role=storagenode)
FromMessageId=0
MessagePartCount=0
PendingCount=0
BufferCounter=1
MessageType=70
ToPollId=19827300
Poll=null
Packets
{
}
Service=PartitionedCache{Name=DistributedCache, State=(SERVICE_STARTED), Id=3, OldestMemberId=1, LocalStorage=enabled, PartitionCount=601, BackupCount=1, AssignedPartitions=18, BackupPartitions=19, CoordinatorId=1}
ToMemberSet=MemberSet(Size=1
Member(Id=179, Timestamp=2023-03-12 18:43:36.847, Address=138.106.96.25:33316, MachineId=48549, Location=site:sss.se.xxxxyyyy.com,machine:l4025p,process:3473,member:l4025p_11990, Role=scex)
)
NotifyDelivery=false
}: peer=tmb://138.106.96.25:33316.40573, state=ACTIVE, socket=MultiplexedSocket{Socket[addr=/138.106.96.25,port=38114,localport=9001]}, migrations=17, bytes(in=104371345, out=101784244), flushlock false, bufferedOut=0B, unflushed=0B, delivered(in=203177, out=197772), timeout(ack=0ns), interestOps=1, unflushed receipt=0, receiptReturn 0, isReceiptFlushRequired false, bufferedIn(), msgs(in=95922, out=99203/99206)
2023-03-13 20:17:56.310/95085.948 Oracle Coherence CE 14.1.1.0.12 (thread=SelectionService(channels=112, selector=MultiplexedSelector(sun.nio.ch.EPollSelectorImpl@3676ac27), id=1660451908), member=17): tmb://138.106.96.41:9001.49982 initiating connection migration with tmb://138.106.96.32:41070.40752 after 15s ack timeout health(read=true, write=false), receiptWait=null: peer=tmb://138.106.96.32:41070.40752, state=ACTIVE, socket=MultiplexedSocket{Socket[addr=/138.106.96.32,port=41070,localport=36388]}, migrations=5, bytes(in=95752773, out=99458811), flushlock false, bufferedOut=1.54KB, unflushed=0B, delivered(in=192506, out=187239), timeout(ack=0ns), interestOps=1, unflushed receipt=0, receiptReturn 0, isReceiptFlushRequired false, bufferedIn(), msgs(in=90667, out=93950/93953)

Version: CE 20.06.1
I created a POF config file "cache-pof-config.xml". And add below to tangosol-coherence-override.xml. When startup, it don't load cache-pof-config.xml. I also tried setting coherence.pof.config system property, didn't work.

<serializers> <serializer id="java"> <class-name>com.tangosol.io.DefaultSerializer</class-name> </serializer> <serializer id="pof"> <class-name>com.tangosol.io.pof.ConfigurablePofContext</class-name> <init-params> <init-param> <param-type>String</param-type> <param-value system-property="coherence.pof.config">cache-pof-config.xml</param-value> </init-param> </init-params> </serializer> </serializers>

In cache config file, it works by setting default serializer.
<defaults> <serializer> <instance> <class-name>com.tangosol.io.pof.ConfigurablePofContext</class-name> <init-params> <init-param> <param-type>String</param-type> <param-value>cache-pof-config.xml</param-value> </init-param> </init-params> </instance> </serializer> </defaults>

Followed description of using POF annotations to leverage generation of Portable Object code for application in ce22.06 guide for key association.

Excerpt from Key Associator guide:

Bothof the model classes are annotated with the @PortableType. This annotation is used by the Coherence POF Maven plugin to generate Portable Object code for the classes. Using the Coherence POF generator in this way avoids having to manually write serialization code and ensures that the serialization code generated is supports evolvability betweenversions.

I am using Graddle and would like to have an equivalent for the POF Maven plugin to generate Portable Object code for the classes.

For now, I am just falling back to specifying user pof-config file and specifying PofSerializers.

The documentation describes quite clearly how to run processors of different kinds for a specific key, for all keys or for each cache node but what about if I want to process the data in each partition separately?

Lacking any "out of the box" solution to do this my current idea is to use an AbstractInvocable that will run on each storage enabled node and then let it find the partitions of the desired cache(s) on that node and do whatever I want to do with them one by one or in parallel (for instance using virtual threads).

I have so far not found how to find the number of partitions on each node (not necessarily perfectly evenly balanced between nodes) or indeed the actual keys/values for each partition :-(

So far I have written this code for my Invocable

InvocationService service = (InvocationService) getService();
cluster = service.getCluster();
Service cacheService = cluster.getService("CacheService");
if (cacheService instanceof CacheService) {
    BackingMapManagerContext context = ((CacheService) cacheService).getBackingMapManager().getContext();
    // ??????
}

Is this the right way to access what I want and if so how do I get further? Cant really find the right methods from here?

When testing for #16 (comment), I used Guava's testlib to validate conformance to the Collections Framework contracts. Running these tests against the existing OldCache uncovered a bug in the iterator.

junit.framework.AssertionFailedError: failed with stimuli [hasNext, hasNext, next, hasNext, remove]

	at com.google.common.collect.testing.Helpers.fail(Helpers.java:248)
	at com.google.common.collect.testing.AbstractIteratorTester.compareResultsForThisListOfStimuli(AbstractIteratorTester.java:370)
	at com.google.common.collect.testing.AbstractIteratorTester.recurse(AbstractIteratorTester.java:344)
	at com.google.common.collect.testing.AbstractIteratorTester.recurse(AbstractIteratorTester.java:349)
	at com.google.common.collect.testing.AbstractIteratorTester.recurse(AbstractIteratorTester.java:349)
	at com.google.common.collect.testing.AbstractIteratorTester.recurse(AbstractIteratorTester.java:349)
	at com.google.common.collect.testing.AbstractIteratorTester.recurse(AbstractIteratorTester.java:349)
	at com.google.common.collect.testing.AbstractIteratorTester.recurse(AbstractIteratorTester.java:349)
	at com.google.common.collect.testing.AbstractIteratorTester.test(AbstractIteratorTester.java:317)
	at com.google.common.collect.testing.testers.CollectionIteratorTester.runIteratorTest(CollectionIteratorTester.java:133)
	at com.google.common.collect.testing.testers.CollectionIteratorTester.testIterator_unknownOrderRemoveSupported(CollectionIteratorTester.java:111)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77)
	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.base/java.lang.reflect.Method.invoke(Method.java:568)
	at junit.framework.TestCase.runTest(TestCase.java:177)
	at junit.framework.TestCase.runBare(TestCase.java:142)
	at junit.framework.TestResult$1.protect(TestResult.java:122)
	at junit.framework.TestResult.runProtected(TestResult.java:142)
	at junit.framework.TestResult.run(TestResult.java:125)
	at junit.framework.TestCase.run(TestCase.java:130)
	at junit.framework.TestSuite.runTest(TestSuite.java:241)
	at junit.framework.TestSuite.run(TestSuite.java:236)
	at junit.framework.TestSuite.runTest(TestSuite.java:241)
	at junit.framework.TestSuite.run(TestSuite.java:236)
	at junit.framework.TestSuite.runTest(TestSuite.java:241)
	at junit.framework.TestSuite.run(TestSuite.java:236)
	at junit.framework.TestSuite.runTest(TestSuite.java:241)
	at junit.framework.TestSuite.run(TestSuite.java:236)
	at junit.framework.TestSuite.runTest(TestSuite.java:241)
	at junit.framework.TestSuite.run(TestSuite.java:236)
	at org.junit.internal.runners.JUnit38ClassRunner.run(JUnit38ClassRunner.java:90)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:69)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater$1.execute(IdeaTestRunner.java:38)
	at com.intellij.rt.execution.junit.TestsRepeater.repeat(TestsRepeater.java:11)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:35)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:235)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:54)
Caused by: junit.framework.AssertionFailedError: Target threw exception when reference did not
	at com.google.common.collect.testing.Helpers.fail(Helpers.java:248)
	at com.google.common.collect.testing.AbstractIteratorTester.internalExecuteAndCompare(AbstractIteratorTester.java:442)
	at com.google.common.collect.testing.AbstractIteratorTester.access$600(AbstractIteratorTester.java:44)
	at com.google.common.collect.testing.AbstractIteratorTester$8.executeAndCompare(AbstractIteratorTester.java:553)
	at com.google.common.collect.testing.AbstractIteratorTester.compareResultsForThisListOfStimuli(AbstractIteratorTester.java:367)
	... 37 more
Caused by: java.lang.IllegalStateException
	at com.tangosol.util.FilterEnumerator.remove(FilterEnumerator.java:157)
	at com.google.common.collect.testing.AbstractIteratorTester$1.execute(AbstractIteratorTester.java:469)
	at com.google.common.collect.testing.AbstractIteratorTester.internalExecuteAndCompare(AbstractIteratorTester.java:398)
	... 40 more

There were also failures due to the custom string representation. Unfortunately there is not a setting to ignore that, as it does seem reasonable for your use-case when debugging. Source code below.

import com.google.common.collect.testing.MapTestSuiteBuilder;
import com.google.common.collect.testing.TestStringMapGenerator;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.collect.testing.features.MapFeature;
import com.tangosol.net.cache.OldCache;
import java.util.Map;
import java.util.Map.Entry;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/** Guava testlib map tests. */
public final class OldCacheMapTests extends TestCase {

  public static TestSuite suite() {
    return MapTestSuiteBuilder
        .using(generator())
        .named("OldCache")
        .withFeatures(
            CollectionSize.ANY,
            MapFeature.GENERAL_PURPOSE,
            MapFeature.ALLOWS_NULL_KEYS,
            MapFeature.ALLOWS_NULL_VALUES,
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .createTestSuite();
  }

  private static TestStringMapGenerator generator() {
    return new TestStringMapGenerator() {
      @Override protected Map<String, String> create(Entry<String, String>[] entries) {
        var cache = new OldCache();
        for (var entry : entries) {
          cache.put(entry.getKey(), entry.getValue());
        }
        return cache;
      }
    };
  }
}

First and foremost a big thank you to Oracle for open-sourcing this great product.

I have a couple of questions for the Oraclers here around:

1 - What will be the future relationship between Community and Coherence Enterprise/Grid in terms of source code?
Will CE be the base for future releases of the commercial product as well?

2 - Version numbering: will at some point Coherence Grid and Enterprise adopt the same version numbering of CE?

TY,

R

I am seeking general advice on how safely "scale in" storage enabled nodes in a cloud environment (in my case AWS)? I would like to use an auto scaling group (ASG) to maintain a (typically slowly varying) number of nodes to accomodate varying need of vCPUs over the day/week to preocess requests to a partitioned cache.
One way would be to only allow the ASG to only scale in ONE node at a time and set a long delay before it is allowed to scale in one more. I would however prefer to instead of a fixed delay use the "lifecycle hook" support of the ASG where I can let a scaled in instance communicate to the ASG when it is ok to kill it (after it has performed an orgerly shutdown).
My question is if there is a simple way for a storage enabled node to tell Coherence that it intends to leave the cluster that will also work if rebalancing is already in progress (for instance due to a node failure) and if so would this mechanism work even if allowing the ASG to scale in more than one node at the same time i.e. would the leaving nodes be allowed to do so in sequence?

Hi,

We have been trying to use the version 21.12.3 of Oracle Coherence in one of our open source projects. We downloaded the version from https://repo.maven.apache.org/maven2/com/oracle/coherence/ce/coherence/21.12.3/coherence-21.12.3-sources.jar. The sources contain the following files with a very restrictive license text:

• com/tangosol/dev/tools/copyright.cmd.txt
• com/tangosol/dev/tools/copyright.sh.txt
• com/tangosol/dev/tools/copyright.txt
• com/tangosol/dev/tools/copyright.xml.txt

The license text is the following:

@Rem Oracle is a registered trademarks of Oracle Corporation and/or its
@Rem affiliates.
@Rem
@Rem This software is the confidential and proprietary information of Oracle
@Rem Corporation. You shall not disclose such confidential and proprietary
@Rem information and shall use it only in accordance with the terms of the
@Rem license agreement you entered into with Oracle.
@Rem
@Rem This notice may not be removed or altered.

This looks strange to us and the license texts seem to be there for historical reasons, and do not apply to any source file.

Does anyone know why the files are there in that version of Coherence, and if it has any relevance or not.

Hi,

We are using weblogic 12.2.1.4 app server to host our java apps. Also using Informix 14 as database. Would it be possible to coherence community edition in this landscape to cache frequently queried data from db to improve performance?

Regards
Jacob

The content of the columns in the PagedTopic MBean attributes table at https://coherence.community/23.03/docs/#/docs/core/02_topics#mbeans appears to be incorrect in the rows after the PublishedMeanRate row.

To reproduce, look at the PagedTopic MBean attributes table at https://coherence.community/23.03/docs/#/docs/core/02_topics#mbeans.

I think what is expected is that the attribute name is in the first column, its type is in the second column, etc.

After having done a, as I think so far, successful test of saving/restoring data from partitioned back tier of a near cache to/from S3 (seem possible to get near half the aggregated link speed of all storage enabled nodes - the other half goes to replication as we uses a backup count of 1) I am thinking if it for the same purpose (i.e. geting test environments up and running as fast as it it is ever possible) is technically possible to write data (in this case of course as Java objects not POF data) to front caches without triggering replication to the back cache (afaik there is no "getFrontCache" but perhaps there is a way to get to the "backing map" directly also on the clients)?
I have found that the front map can be accessed by casting the cache to CacheMap but inserting objects to the front map will still replicate to the backing map so that alone does not seem to make what I want possible... I guess I would like to do a "synthetic" put if that was possible.

If this was possible one could create an S3 backup of the front cache in the client with the highest hit rate that, when new test environments are created, is restored on every non-storage enabled node while a corresponding L2 (back tier) snapshot is loaded...

With a lot of L1 (front) caches loading them all at startup with hot content takes a fairly long time for us (and puts HEAVY load on the L2 back tier). For context we need to pre-load L1 as the object in our application are not read in bulk but rather discovered little by little (i.e. each object contain keys to other objects forming a type of "graph") resulting in potentially tens of thousands of individual cache misses (each causing a remote request to the back cache) with an empty L1 front cache - i.e. if not doing pre-loading quite many client requests will take many seconds or even a minute or more to complete resulting in unacceptable user experience (or even HTTP timeouts for service invocations) :-(

Today we first load more or less our entire database to the L2 back tier (for test environments till will be replaced by the loading from S3) and then load a large number of frequently used objects on each L2 front cache that I also would like to replace with parallel direct loading from S3 to each non-storage enabled node...

After a long period of using a Windows I just switched back to using Mac (this time ARM M3) and ran into a problem I have never experienced before starting Coherence locally :-(

This is using Coherence CE 24.03, Java Open JDK 21 and MacOS Sonoma 14.3.1

When I run "mvn exec:java -Dexec.mainClass="com.tangosol.net.DefaultCacheServer" I get an error message saying "multicast networking appears to be inoperable on interface 192.168.1.19 as this process isn't receiving even its own transmissions"...

Just for fun I tested using the coherence console app and to my surprise it can without any problem start a 3 node cluster, I could insert data etc. so there is nothing wrong with the MacOS setup it seems so the question is why I get this error when I try to do it myself using mvn rather than with the command line client?!

I also tried the suggested work-around of setting "set JAVA_TOOL_OPTS="-Djava.net.preferIPv4Stack=true" but it did not make any difference so the problem seem to be something else...

I also tried copying and running the exact same project on one of my Windows boxes and there it ran as it always have without any errors....

Probably some really silly Mac beginners misstake but right now I do not see it... suggestions appreciated!

Type of question

Coherence CPU architecture support

Question

Does Coherence work on ARM architecture (like the AWS Graviton2) or only with X86?

According to the documentation shared between Oracle Coherence and Coherence CE one should be able to specify an "override file" with -Dtangosol.coherence.override but as far as we can tell (we just noticed it and is still investigating/finding work arounds), at least in V14 that we still use, this parameter is ignored by CE and only the file "jar:file:/opt/oas/cache/lib/cache-coherence-2.7941.0.jar!/tangosol-coherence-override-prod.xml" seem to be read?!
Not sure if this is the intended behaviour in CE and if so is it documented somewhere?

Enhancement Request

Is your feature request related to a problem? Please describe.
Currently, the cache supports the policies LRU, LFU, and a Hybrid (default). Unfortunately in many workloads these algorithms have low hit rates.

Describe the solution you'd like
Incorporate a modern algorithms, borrowing from Caffeine. Perhaps ideally there would be a direct dependency, e.g. to take advantage of it being concurrent (whereas LocalCache is fully synchronized). However that is a unreasonly significant change, so instead a port of the algorithm is provided into your APIs (commit) to assist in the initial bootstrapping.

The bootstrap commit leaves a few gaps such as

• Loop during eviction to discard multiple entries when required by custom unit sizes
• Unit / Integration testing
• Style, formatting, etc
• External configuration

Additional context
Window TinyLFU (W-TinyLFU) is a modern eviction policy that outperforms the currently implemented algorithms: LRU, LFU, and Hybrid (default).

W-TinyLFU utilizes a popularity sketch, CountMin, to compactly estimate the frequency over a time period. This sketch is used as a frequency filter by comparing the entry being added to the cache to eviction policy's victim. If the victim is more popular then the candidate is discarded, which avoids polluting the cache with "one-hit wonders". The sketch is aged by halving all of its counters periodically. Because it only needs to detect heavy hitters, a matrix of 4-bit counters is used.

In recency-biased workloads, aggressively filtering by the frequency can reduce the hit rate. Therefore the cache is split into two LRUs, one before and one after the filter, and uses TinyLFU to conditionally promote. Thus the admission window's victim and the main space's compete. Since the main region is frequency-biased, it uses SLRU to choose a better victim.

The optimal relative size of these two regions is workload dependent. It is configured dynamically by using hill climbing. The hit rate is sampled and the admission window's size is increased or decreased depending on whether the last guess was beneficial. Eventually the climber oscillates around the best configuration, so the step size decays gradually to allow for convergence. An adaption will restart if the hit rate changes dramatically, indicating different workload.

The hit rate across a variety of workloads shows a significant improvement.

Type of question

I would like to know more about the background of the TDE toolchain and the CDB files which seem to be used as basis for generating large parts of the Coherence code.

Question

What did you do?

I wanted to do some experiments by tweaking the method public QueryResult query(Filter filter, int nQueryType, PartitionSet partMask) in com.tangosol.coherence.component.util.daemon.queueProcessor.service.grid.partitionedService.PartitionedCache$Storage but struggled to find the Java source code for this.

It seems that the code is generated out of tde/core-net/3.0/cdb/Component/Util/Daemon/QueueProcessor/Service/Grid/PartitionedService/PartitionedCache.cdb (and a lot of other code too analogously)?

I found the tde utility (Tangsol Desktop) under tools/bin/tde which allows to open those cdb files and look at them/modify them. With a bit of try and error I managed to modify the method I was interested in and by re-running the toolchain get the result I wanted to in the first place, but to be honest, half of the time I did not understand what I was doing.

So my questions are:

1. What are those cdb files and the tde tool and what is the general idea behind it? Is this something tangosol-properitary or part of/based on some other tooling?
2. Is there some documentation on how it all works in more details (e. g. what do all the options mean in tde, how as a developer you are supposed to use the tool, where would you do changes to code if you want to introduce new functionality, etc.)?
3. Are there plans to move away from this toolchain to something, let's say, more intuitive to the regular developer or is the current situation that tde/cdb is just too tightly integrated into the Coherence DNA to make it worth the effort?

Thanks, regards, Leo

What did you expect to see?
I would like to see documentation about TDE and the CDB format.

What did you see instead? Under which circumstances?
I couldn't find any documentation.

Environment
N/a

Additional context
N/a