Cache connectivity and reduce mapping cache churn

Author: asad

src/main/java/com/bioinceptionlabs/reactionblast/mapping/GraphMatcher.java

@@ -1004,6 +1004,7 @@ public static class MCSThread implements Callable<MCSSolution> {
         private final int invocationIndex;
         private final Map<String, Integer> compound1SymbolCounts;
         private final Map<String, Integer> compound2SymbolCounts;
+        private final boolean moleculesConnected;
 
         /**
          *
@@ -1042,6 +1043,7 @@ public static class MCSThread implements Callable<MCSSolution> {
             this.numberOfCyclesProduct = 0;
             this.compound1SymbolCounts = countAtomsBySymbol(this.compound1);
             this.compound2SymbolCounts = countAtomsBySymbol(this.compound2);
+            this.moleculesConnected = isConnected(this.compound1) && isConnected(this.compound2);
         }
 
         void printMatch(BaseMapping isomorphism) {
@@ -1078,7 +1080,7 @@ public MCSSolution call() throws Exception {
                 /*
                  * IMP: Do not perform substructure matching for disconnected molecules
                  */
-                boolean moleculeConnected = isMoleculeConnected(getCompound1(), getCompound2());
+                boolean moleculeConnected = moleculesConnected;
                 /*
                      Check if MCS matching required or not very IMP step
                  */
@@ -1308,24 +1310,25 @@ MCSSolution mcs() throws CDKException, CloneNotSupportedException {
             bm = AtomBondMatcher.bondMatcher(settings.bondMatch, settings.ringMatch);
 
             key = generateUniqueKey(settings);
-            if (ThreadSafeCache.getInstance().containsKey(key)) {
+            ThreadSafeCache<String, MCSSolution> mappingCache = ThreadSafeCache.getInstance();
+            MCSSolution cachedSolution = mappingCache.get(key);
+            if (cachedSolution != null) {
                 LOGGER.debug("===={Aladdin} Mapping {Gini}====");
                 MappingDiagnostics.recordMcsCacheHit(reactionId, algorithmName, invocationIndex);
-                MCSSolution solution = (MCSSolution) ThreadSafeCache.getInstance().get(key);
                 mcs = copyOldSolutionToNew(
                         getQueryPosition(), getTargetPosition(),
                         getCompound1(), getCompound2(),
-                        solution);
+                        cachedSolution);
 
             } else {
                 SearchEngine.McsOptions mcsOptions = new SearchEngine.McsOptions();
                 mcsOptions.timeoutMs = MCS_TIMEOUT_MS;
-                mcsOptions.connectedOnly = isMoleculeConnected(ac1, ac2);
+                mcsOptions.connectedOnly = moleculesConnected;
                 mcsOptions.disconnectedMCS = !mcsOptions.connectedOnly;
                 mcsOptions.maximizeBonds = settings.bondMatch;
                 MappingDiagnostics.recordActualMcsSearch(reactionId, algorithmName, invocationIndex);
                 isomorphism = MAPPING_ENGINE.findMcs(ac1, ac2, Algorithm.VFLibMCS, am, bm, mcsOptions);
-                mcs = addMCSSolution(key, ThreadSafeCache.getInstance(), isomorphism);
+                mcs = addMCSSolution(key, mappingCache, isomorphism);
             }
 
             return mcs;
@@ -1452,23 +1455,10 @@ boolean isHasPerfectRings() {
         /*
          * Check if fragmented container has single atom
          */
-        private boolean isMoleculeConnected(IAtomContainer compound1, IAtomContainer compound2) {
-            LOGGER.debug("isMoleculeConnected");
-            boolean connected1 = true;
-
-            IAtomContainerSet partitionIntoMolecules = ConnectivityChecker.partitionIntoMolecules(compound1);
-            if (partitionIntoMolecules.getAtomContainerCount() > 1) {
-                connected1 = false;
-            }
-
-            boolean connected2 = true;
-
-            partitionIntoMolecules = ConnectivityChecker.partitionIntoMolecules(compound2);
-            if (partitionIntoMolecules.getAtomContainerCount() > 1) {
-                connected2 = false;
-            }
-
-            return connected1 && connected2;
+        private boolean isConnected(IAtomContainer compound) {
+            LOGGER.debug("isConnected");
+            IAtomContainerSet partitionIntoMolecules = ConnectivityChecker.partitionIntoMolecules(compound);
+            return partitionIntoMolecules.getAtomContainerCount() <= 1;
         }
 
         void setEductRingCount(int numberOfCyclesEduct) {
@@ -1527,14 +1517,18 @@ MCSSolution addMCSSolution(String key, ThreadSafeCache<String, MCSSolution> mapp
             long time = stopTime - startTime;
             printMatch(isomorphism);
             LOGGER.debug("\" Time:\" " + time);
-            if (!mappingcache.containsKey(key)) {
+            MCSSolution cached = mappingcache.putIfAbsent(key, mcs);
+            if (cached == mcs) {
                 LOGGER.debug("Key " + key);
                 LOGGER.debug("mcs size " + mcs.getAtomAtomMapping().getCount());
                 LOGGER.debug("mcs map " + mcs.getAtomAtomMapping().getMappingsByIndex());
                 LOGGER.debug("\n\n\n ");
-                mappingcache.put(key, mcs);
+                return mcs;
             }
-            return mcs;
+            return copyOldSolutionToNew(
+                    getQueryPosition(), getTargetPosition(),
+                    getCompound1(), getCompound2(),
+                    cached);
         }
     }
 

src/main/java/com/bioinceptionlabs/reactionblast/mapping/ThreadSafeCache.java

@@ -65,6 +65,29 @@ public boolean containsKey(K key) {
         return map.containsKey(key);
     }
 
+    /**
+     * Insert the value only if the key is absent.
+     *
+     * @return the existing value if present, otherwise the inserted value
+     */
+    public V putIfAbsent(K key, V value) {
+        if (map.size() >= MAX_CAPACITY) {
+            evict();
+        }
+        if (map instanceof ConcurrentHashMap<?, ?> concurrentMap) {
+            @SuppressWarnings("unchecked")
+            ConcurrentHashMap<K, V> typedMap = (ConcurrentHashMap<K, V>) concurrentMap;
+            V existing = typedMap.putIfAbsent(key, value);
+            return existing != null ? existing : value;
+        }
+        V existing = map.get(key);
+        if (existing == null) {
+            map.put(key, value);
+            return value;
+        }
+        return existing;
+    }
+
     /**
      * Clear all cached entries. Use sparingly — cross-reaction caching
      * benefits from keeping the cache warm between reactions.

src/main/java/com/bioinceptionlabs/reactionblast/mapping/algorithm/GameTheoryEngine.java

@@ -415,20 +415,23 @@ private MCSSolution quickMapping(String reactionId, String algorithmName,
                     educt.getBondCount(), product.getBondCount(),
                     false, false, false, false,
                     numberOfCyclesEduct, numberOfCyclesProduct);
-            if (mappingcache.containsKey(key)) {
+            MCSSolution cached = mappingcache.get(key);
+            if (cached != null) {
                 MappingDiagnostics.recordQuickMappingCacheHit(reactionId, algorithmName);
-                MCSSolution solution = mappingcache.get(key);
                 MCSSolution mcs = copyOldSolutionToNew(
                         queryPosition, targetPosition,
-                        educt, product, solution);
+                        educt, product, cached);
                 return mcs;
             } else {
                 AtomMatcher atomMatcher = AtomBondMatcher.atomMatcher(false, false);
                 BondMatcher bondMatcher = AtomBondMatcher.bondMatcher(false, false);
                 MappingDiagnostics.recordQuickMappingSearch(reactionId, algorithmName);
                 BaseMapping isomorphism = MAPPING_ENGINE.findMcs(
                         educt, product, Algorithm.DEFAULT, atomMatcher, bondMatcher);
-                MCSSolution mcs = addMCSSolution(queryPosition, targetPosition, key, mappingcache, isomorphism);
+                MCSSolution mcs = addMCSSolution(
+                        queryPosition, targetPosition,
+                        educt, product,
+                        key, mappingcache, isomorphism);
                 return mcs;
             }
         } catch (CDKException ex) {
@@ -562,17 +565,19 @@ MCSSolution copyOldSolutionToNew(int queryPosition, int targetPosition,
     }
 
     MCSSolution addMCSSolution(int queryPosition, int targetPosition,
+            IAtomContainer educt, IAtomContainer product,
             String key, ThreadSafeCache<String, MCSSolution> mappingcache, BaseMapping isomorphism) {
         MAPPING_ENGINE.applyDefaultFilters(isomorphism);
         MCSSolution mcs = new MCSSolution(queryPosition, targetPosition,
                 isomorphism.getQuery(), isomorphism.getTarget(), isomorphism.getFirstAtomMapping());
         mcs.setEnergy(isomorphism.getEnergyScore(0));
         mcs.setFragmentSize(isomorphism.getFragmentSize(0));
         mcs.setStereoScore(isomorphism.getStereoScore(0));
-        if (!mappingcache.containsKey(key)) {
-            mappingcache.put(key, mcs);
+        MCSSolution cached = mappingcache.putIfAbsent(key, mcs);
+        if (cached == mcs) {
+            return mcs;
         }
-        return mcs;
+        return copyOldSolutionToNew(queryPosition, targetPosition, educt, product, cached);
     }
 
     // ========== Inner class: GameTheoryFactory ==========