Multiple readers and variable optimization

[simantics/platform.git] / bundles / org.simantics.db.impl / src / org / simantics / db / impl / query / QueryCache.java

diff --git a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCache.java b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCache.java
index dbd0068c3f66100404eda02d5fbba9d70fdc8308..49e02dece32049884f7a3907e85f960f2bf27f64 100644 (file)
--- a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCache.java
+++ b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCache.java
@@ -1,5 +1,6 @@
 package org.simantics.db.impl.query;
 
+import org.simantics.db.ObjectResourceIdMap;
 import org.simantics.db.RelationInfo;
 import org.simantics.db.exception.DatabaseException;
 import org.simantics.db.impl.graph.ReadGraphImpl;
@@ -30,6 +31,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 objectsMap.put(keyR2(r1,r2), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -48,11 +50,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
             Objects.computeForEach(graph, r1,r2, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureObjects;
         Objects entry = (Objects)cache.getOrCreateObjects(r1,r2);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -72,6 +74,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 statementsMap.put(keyR2(r1,r2), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -90,11 +93,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, TripleIntProcedure procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
             Statements.computeForEach(graph, r1,r2, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureStatements;
         Statements entry = (Statements)cache.getOrCreateStatements(r1,r2);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -114,6 +117,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 directObjectsMap.put(keyR2(r1,r2), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -132,11 +136,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerDirectObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
             DirectObjects.computeForEach(graph, r1,r2, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureDirectObjects;
         DirectObjects entry = (DirectObjects)cache.getOrCreateDirectObjects(r1,r2);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -156,6 +160,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 relationInfoQueryMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -174,11 +179,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerRelationInfoQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<RelationInfo> procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             RelationInfoQuery.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureRelationInfoQuery;
         RelationInfoQuery entry = (RelationInfoQuery)cache.getOrCreateRelationInfoQuery(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -198,6 +203,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 uRIToResourceMap.put(keyID(id), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -216,11 +222,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerURIToResource(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, InternalProcedure<Integer> procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, id)) {
             URIToResource.computeForEach(graph, id, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureURIToResource;
         URIToResource entry = (URIToResource)cache.getOrCreateURIToResource(id);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -240,6 +246,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 valueQueryMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -258,11 +265,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerValueQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<byte[]> procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             ValueQuery.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureValueQuery;
         ValueQuery entry = (ValueQuery)cache.getOrCreateValueQuery(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -282,6 +289,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 orderedSetMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -300,11 +308,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerOrderedSet(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             OrderedSet.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureOrderedSet;
         OrderedSet entry = (OrderedSet)cache.getOrCreateOrderedSet(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -324,6 +332,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 principalTypesMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -342,11 +351,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerPrincipalTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             PrincipalTypes.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedurePrincipalTypes;
         PrincipalTypes entry = (PrincipalTypes)cache.getOrCreatePrincipalTypes(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -366,6 +375,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 directPredicatesMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -384,11 +394,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerDirectPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             DirectPredicates.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureDirectPredicates;
         DirectPredicates entry = (DirectPredicates)cache.getOrCreateDirectPredicates(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -408,6 +418,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 predicatesMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -426,11 +437,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             Predicates.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedurePredicates;
         Predicates entry = (Predicates)cache.getOrCreatePredicates(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -450,6 +461,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 readEntryMap.put(id(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -468,11 +480,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerReadEntry(ReadGraphImpl graph, Read<?> r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             ReadEntry.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureReadEntry;
         ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -492,6 +504,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 asyncReadEntryMap.put(id(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -510,11 +523,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerAsyncReadEntry(ReadGraphImpl graph, AsyncRead<?> r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             AsyncReadEntry.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureAsyncReadEntry;
         AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -534,6 +547,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 typesMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -552,11 +566,11 @@ public class QueryCache extends QueryCacheBase {
     }
     
     public static void runnerTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
             Types.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
         if(procedure == null) procedure = emptyProcedureTypes;
         Types entry = (Types)cache.getOrCreateTypes(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
@@ -567,15 +581,16 @@ public class QueryCache extends QueryCacheBase {
         }
     }
     
-    NamespaceIndex getOrCreateNamespaceIndex(String id) throws DatabaseException {
-        NamespaceIndex existing = null;
-        synchronized(namespaceIndexMap) {
-            existing = (NamespaceIndex)namespaceIndexMap.get(id);
+    ChildMap getOrCreateChildMap(int r) throws DatabaseException {
+        ChildMap existing = null;
+        synchronized(childMapMap) {
+            existing = (ChildMap)childMapMap.get(r);
             if(existing == null) {
-                existing = new NamespaceIndex(id);
+                existing = new ChildMap(r);
                 existing.clearResult(querySupport);
                 existing.setPending();
-                namespaceIndexMap.put(keyID(id), existing);
+                childMapMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -587,24 +602,24 @@ public class QueryCache extends QueryCacheBase {
         return existing;
     }
     
-    void remove(NamespaceIndex entry) {
-        synchronized(namespaceIndexMap) {
-            namespaceIndexMap.remove(entry.id);
+    void remove(ChildMap entry) {
+        synchronized(childMapMap) {
+            childMapMap.remove(entry.id);
         }
     }
     
-    public static void runnerNamespaceIndex(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, InternalProcedure<TObjectIntHashMap<String>> procedure) throws DatabaseException {
-        if(parent == null && listener == null) {
-            NamespaceIndex.computeForEach(graph, id, null, procedure);
+    public static void runnerChildMap(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<ObjectResourceIdMap<String>> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            ChildMap.computeForEach(graph, r, null, procedure);
             return;
         }
-        QueryCache cache  = graph.processor.cache;
-        if(procedure == null) procedure = emptyProcedureNamespaceIndex;
-        NamespaceIndex entry = (NamespaceIndex)cache.getOrCreateNamespaceIndex(id);
+        if(procedure == null) procedure = emptyProcedureChildMap;
+        ChildMap entry = (ChildMap)cache.getOrCreateChildMap(r);
         ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
         if(entry.isReady()) entry.performFromCache(graph, procedure);
         else {
-            NamespaceIndex.computeForEach(graph, id, entry, procedure);
+            ChildMap.computeForEach(graph, r, entry, procedure);
             if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
         }
     }
@@ -618,6 +633,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 assertedStatementsMap.put(keyR2(r1,r2), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -656,6 +672,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 assertedPredicatesMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -694,6 +711,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 directSuperRelationsMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -732,6 +750,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 superTypesMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -770,6 +789,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 typeHierarchyMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -808,6 +828,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 superRelationsMap.put(keyR(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -846,6 +867,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 multiReadEntryMap.put(id(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -884,6 +906,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 asyncMultiReadEntryMap.put(id(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {
@@ -922,6 +945,7 @@ public class QueryCache extends QueryCacheBase {
                 existing.clearResult(querySupport);
                 existing.setPending();
                 externalReadEntryMap.put(id(r), existing);
+                size++;
                 return existing;
             }
             if(existing.requiresComputation()) {