X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.db.impl%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fimpl%2Fquery%2FQueryCache.java;h=3e7a25190df94fe225f803bea23215c770727417;hb=68ce0966a57f5153b133c6283fdbae10f683b745;hp=4be12da47d582b08cf0d6dfe16129d42650c7509;hpb=ad18bf76b19bec530bc68c6041ab5fb245b8ee4d;p=simantics%2Fplatform.git 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 4be12da47..3e7a25190 100644 --- 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,9 +1,12 @@ package org.simantics.db.impl.query; +import org.simantics.db.ObjectResourceIdMap; import org.simantics.db.RelationInfo; +import org.simantics.db.common.utils.Logger; import org.simantics.db.exception.DatabaseException; import org.simantics.db.impl.graph.ReadGraphImpl; import org.simantics.db.impl.procedure.InternalProcedure; +import org.simantics.db.impl.query.QueryProcessor.SessionTask; import org.simantics.db.procedure.AsyncMultiProcedure; import org.simantics.db.procedure.AsyncProcedure; import org.simantics.db.procedure.ListenerBase; @@ -30,6 +33,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); objectsMap.put(keyR2(r1,r2), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -47,18 +51,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureObjects; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - Objects.computeForEach(graph, r1,r2, entry, procedure); + assert(entry.isPending()); + Objects.computeForEach(graph, r1,r2, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -72,6 +77,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); statementsMap.put(keyR2(r1,r2), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -89,18 +95,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, TripleIntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureStatements; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - Statements.computeForEach(graph, r1,r2, entry, procedure); + assert(entry.isPending()); + Statements.computeForEach(graph, r1,r2, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -114,6 +121,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); directObjectsMap.put(keyR2(r1,r2), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -131,18 +139,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerDirectObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerDirectObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectObjects; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - DirectObjects.computeForEach(graph, r1,r2, entry, procedure); + assert(entry.isPending()); + DirectObjects.computeForEach(graph, r1,r2, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -156,6 +165,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); relationInfoQueryMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -173,18 +183,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerRelationInfoQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerRelationInfoQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedureRelationInfoQuery; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - RelationInfoQuery.computeForEach(graph, r, entry, procedure); + assert(entry.isPending()); + RelationInfoQuery.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -198,6 +209,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); uRIToResourceMap.put(keyID(id), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -215,18 +227,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerURIToResource(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerURIToResource(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedureURIToResource; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - URIToResource.computeForEach(graph, id, entry, procedure); + assert(entry.isPending()); + URIToResource.computeForEach(graph, id, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -240,6 +253,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); valueQueryMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -257,18 +271,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerValueQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerValueQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedureValueQuery; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - ValueQuery.computeForEach(graph, r, entry, procedure); + assert(entry.isPending()); + ValueQuery.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -282,6 +297,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); orderedSetMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -299,18 +315,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerOrderedSet(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerOrderedSet(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureOrderedSet; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - OrderedSet.computeForEach(graph, r, entry, procedure); + assert(entry.isPending()); + OrderedSet.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -324,6 +341,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); principalTypesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -341,18 +359,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerPrincipalTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerPrincipalTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + IntProcedure procedure_ = procedure != null ? procedure : emptyProcedurePrincipalTypes; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - PrincipalTypes.computeForEach(graph, r, entry, procedure); + assert(entry.isPending()); + PrincipalTypes.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -366,6 +385,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); directPredicatesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -383,18 +403,19 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerDirectPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerDirectPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectPredicates; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - DirectPredicates.computeForEach(graph, r, entry, procedure); + assert(entry.isPending()); + DirectPredicates.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -408,6 +429,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); predicatesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -425,23 +447,24 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedurePredicates; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - Predicates.computeForEach(graph, r, entry, procedure); + assert(entry.isPending()); + Predicates.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } - ReadEntry getOrCreateReadEntry(Read r) throws DatabaseException { + ReadEntry getOrCreateReadEntry(Read r, boolean isSync) throws DatabaseException { ReadEntry existing = null; synchronized(readEntryMap) { existing = (ReadEntry)readEntryMap.get(r); @@ -450,6 +473,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); readEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -457,7 +481,10 @@ public class QueryCache extends QueryCacheBase { return existing; } } - if(existing.isPending()) waitPending(existing); + if(existing.isPending()) { + if(isSync) waitPending(existing); + else return null; + } return existing; } @@ -467,18 +494,94 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerReadEntry(ReadGraphImpl graph, Read r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerReadEntry(ReadGraphImpl graph, Read r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure, boolean isSync) throws DatabaseException { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { ReadEntry.computeForEach(graph, r, null, procedure); return; } + ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(r, isSync); + if(entry == null) { + graph.processor.schedule(Integer.MIN_VALUE, new SessionTask(r, graph.processor.THREAD_MASK+1, -1) { + @Override + public void run(int thread) { + try { + assert(!isSync); + runnerReadEntry(graph, r, parent, listener, procedure, isSync); + } catch (DatabaseException e) { + Logger.defaultLogError(e); + } + } + }); + return; + } + AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureReadEntry; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); + else { + assert(entry.isPending()); + ReadEntry.computeForEach(graph, r, entry, procedure_); + if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); + } + } + + AsyncReadEntry getOrCreateAsyncReadEntry(AsyncRead r, boolean isSync) throws DatabaseException { + AsyncReadEntry existing = null; + synchronized(asyncReadEntryMap) { + existing = (AsyncReadEntry)asyncReadEntryMap.get(r); + if(existing == null) { + existing = new AsyncReadEntry(r); + existing.clearResult(querySupport); + existing.setPending(); + asyncReadEntryMap.put(id(r), existing); + size++; + return existing; + } + if(existing.requiresComputation()) { + existing.setPending(); + return existing; + } + } + if(existing.isPending()) { + if(isSync) waitPending(existing); + else return null; + } + return existing; + } + + void remove(AsyncReadEntry entry) { + synchronized(asyncReadEntryMap) { + asyncReadEntryMap.remove(entry.request); + } + } + + public static void runnerAsyncReadEntry(ReadGraphImpl graph, AsyncRead r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure, boolean isSync) throws DatabaseException { 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { + AsyncReadEntry.computeForEach(graph, r, null, procedure); + return; + } + AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(r, isSync); + if(entry == null) { + graph.processor.schedule(Integer.MIN_VALUE, new SessionTask(r, graph.processor.THREAD_MASK+1, -1) { + @Override + public void run(int thread) { + try { + assert(!isSync); + runnerAsyncReadEntry(graph, r, parent, listener, procedure, isSync); + } catch (DatabaseException e) { + Logger.defaultLogError(e); + } + } + }); + return; + } + AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureAsyncReadEntry; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - ReadEntry.computeForEach(graph, r, entry, procedure); + assert(entry.isPending()); + AsyncReadEntry.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -492,6 +595,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); typesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -509,31 +613,33 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + public static void runnerTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { + 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedureTypes; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - Types.computeForEach(graph, r, entry, procedure); + assert(entry.isPending()); + Types.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } - AssertedStatements getOrCreateAssertedStatements(int r1, int r2) throws DatabaseException { - AssertedStatements existing = null; - synchronized(assertedStatementsMap) { - existing = (AssertedStatements)assertedStatementsMap.get(r1,r2); + ChildMap getOrCreateChildMap(int r) throws DatabaseException { + ChildMap existing = null; + synchronized(childMapMap) { + existing = (ChildMap)childMapMap.get(r); if(existing == null) { - existing = new AssertedStatements(r1,r2); + existing = new ChildMap(r); existing.clearResult(querySupport); existing.setPending(); - assertedStatementsMap.put(keyR2(r1,r2), existing); + childMapMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -545,33 +651,39 @@ public class QueryCache extends QueryCacheBase { return existing; } - void remove(AssertedStatements entry) { - synchronized(assertedStatementsMap) { - assertedStatementsMap.remove(entry.id); + void remove(ChildMap entry) { + synchronized(childMapMap) { + childMapMap.remove(entry.id); } } - static void runnerAssertedStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, TripleIntProcedure procedure) throws DatabaseException { + public static void runnerChildMap(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure> procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureAssertedStatements; - AssertedStatements entry = (AssertedStatements)cache.getOrCreateAssertedStatements(r1,r2); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { + ChildMap.computeForEach(graph, r, null, procedure); + return; + } + ChildMap entry = (ChildMap)cache.getOrCreateChildMap(r); + InternalProcedure> procedure_ = procedure != null ? procedure : emptyProcedureChildMap; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + ChildMap.computeForEach(graph, r, entry, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } - NamespaceIndex getOrCreateNamespaceIndex(String id) throws DatabaseException { - NamespaceIndex existing = null; - synchronized(namespaceIndexMap) { - existing = (NamespaceIndex)namespaceIndexMap.get(id); + AssertedStatements getOrCreateAssertedStatements(int r1, int r2) throws DatabaseException { + AssertedStatements existing = null; + synchronized(assertedStatementsMap) { + existing = (AssertedStatements)assertedStatementsMap.get(r1,r2); if(existing == null) { - existing = new NamespaceIndex(id); + existing = new AssertedStatements(r1,r2); existing.clearResult(querySupport); existing.setPending(); - namespaceIndexMap.put(keyID(id), existing); + assertedStatementsMap.put(keyR2(r1,r2), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -583,20 +695,21 @@ public class QueryCache extends QueryCacheBase { return existing; } - void remove(NamespaceIndex entry) { - synchronized(namespaceIndexMap) { - namespaceIndexMap.remove(entry.id); + void remove(AssertedStatements entry) { + synchronized(assertedStatementsMap) { + assertedStatementsMap.remove(entry.id); } } - static void runnerNamespaceIndex(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, InternalProcedure> procedure) throws DatabaseException { + public static void runnerAssertedStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureNamespaceIndex; - NamespaceIndex entry = (NamespaceIndex)cache.getOrCreateNamespaceIndex(id); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + AssertedStatements entry = (AssertedStatements)cache.getOrCreateAssertedStatements(r1,r2); + TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedStatements; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -610,6 +723,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); assertedPredicatesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -627,14 +741,15 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerAssertedPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { + public static void runnerAssertedPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureAssertedPredicates; AssertedPredicates entry = (AssertedPredicates)cache.getOrCreateAssertedPredicates(r); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedPredicates; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -648,6 +763,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); directSuperRelationsMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -665,14 +781,15 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerDirectSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { + public static void runnerDirectSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureDirectSuperRelations; DirectSuperRelations entry = (DirectSuperRelations)cache.getOrCreateDirectSuperRelations(r); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectSuperRelations; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -686,6 +803,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); superTypesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -703,14 +821,15 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerSuperTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { + public static void runnerSuperTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureSuperTypes; SuperTypes entry = (SuperTypes)cache.getOrCreateSuperTypes(r); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedureSuperTypes; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -724,6 +843,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); typeHierarchyMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -741,14 +861,15 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerTypeHierarchy(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { + public static void runnerTypeHierarchy(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureTypeHierarchy; TypeHierarchy entry = (TypeHierarchy)cache.getOrCreateTypeHierarchy(r); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedureTypeHierarchy; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -762,6 +883,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); superRelationsMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -779,52 +901,15 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { + public static void runnerSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureSuperRelations; SuperRelations entry = (SuperRelations)cache.getOrCreateSuperRelations(r); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); - else { - entry.compute(graph, procedure); - if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); - } - } - - AsyncReadEntry getOrCreateAsyncReadEntry(AsyncRead r) throws DatabaseException { - AsyncReadEntry existing = null; - synchronized(asyncReadEntryMap) { - existing = (AsyncReadEntry)asyncReadEntryMap.get(r); - if(existing == null) { - existing = new AsyncReadEntry(r); - existing.clearResult(querySupport); - existing.setPending(); - asyncReadEntryMap.put(id(r), existing); - return existing; - } - if(existing.requiresComputation()) { - existing.setPending(); - return existing; - } - } - if(existing.isPending()) waitPending(existing); - return existing; - } - - void remove(AsyncReadEntry entry) { - synchronized(asyncReadEntryMap) { - asyncReadEntryMap.remove(entry.request); - } - } - - static void runnerAsyncReadEntry(ReadGraphImpl graph, AsyncRead r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException { - 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); - if(entry.isReady()) entry.performFromCache(graph, procedure); + InternalProcedure procedure_ = procedure != null ? procedure : emptyProcedureSuperRelations; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -838,6 +923,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); multiReadEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -855,14 +941,15 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerMultiReadEntry(ReadGraphImpl graph, MultiRead r, CacheEntry parent, ListenerBase listener, AsyncMultiProcedure procedure) throws DatabaseException { + public static void runnerMultiReadEntry(ReadGraphImpl graph, MultiRead r, CacheEntry parent, ListenerBase listener, final AsyncMultiProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureMultiReadEntry; MultiReadEntry entry = (MultiReadEntry)cache.getOrCreateMultiReadEntry(r); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + AsyncMultiProcedure procedure_ = procedure != null ? procedure : emptyProcedureMultiReadEntry; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -876,6 +963,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); asyncMultiReadEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -893,14 +981,15 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead r, CacheEntry parent, ListenerBase listener, AsyncMultiProcedure procedure) throws DatabaseException { + public static void runnerAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead r, CacheEntry parent, ListenerBase listener, final AsyncMultiProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureAsyncMultiReadEntry; AsyncMultiReadEntry entry = (AsyncMultiReadEntry)cache.getOrCreateAsyncMultiReadEntry(r); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + AsyncMultiProcedure procedure_ = procedure != null ? procedure : emptyProcedureAsyncMultiReadEntry; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -914,6 +1003,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); externalReadEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -931,14 +1021,15 @@ public class QueryCache extends QueryCacheBase { } } - static void runnerExternalReadEntry(ReadGraphImpl graph, ExternalRead r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException { + public static void runnerExternalReadEntry(ReadGraphImpl graph, ExternalRead r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure) throws DatabaseException { QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureExternalReadEntry; ExternalReadEntry entry = (ExternalReadEntry)cache.getOrCreateExternalReadEntry(r); - ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); - if(entry.isReady()) entry.performFromCache(graph, procedure); + AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureExternalReadEntry; + ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false); + if(entry.isReady()) entry.performFromCache(graph, procedure_); else { - entry.compute(graph, procedure); + assert(entry.isPending()); + entry.compute(graph, procedure_); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } }