From: jsimomaa Date: Fri, 21 Dec 2018 13:33:19 +0000 (+0200) Subject: Use query caching previous to multi-query-thread to retain performance X-Git-Tag: v1.43.0~136^2~215 X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=commitdiff_plain;h=45548cb3447414845d4672b70e22181eeb3a3487;p=simantics%2Fplatform.git Use query caching previous to multi-query-thread to retain performance gitlab #5 Change-Id: I5ea3de8d088ad97d465ae67521fe107a60c8258a --- diff --git a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/CodeGen.java b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/CodeGen.java index 2f14b98a5..8661428cb 100644 --- a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/CodeGen.java +++ b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/CodeGen.java @@ -47,6 +47,13 @@ public class CodeGen { line(content, " QueryCache cache = graph.processor.cache;"); if(shortcut) { line(content, " if(parent == null && listener == null && !cache.shouldCache(graph.processor, " + signature[1] + ")) {"); + line(content, " if (SINGLE) {"); + line(content, " " + clazz + " e = cache.peek" + clazz + "(" + signature[1] + ");"); + line(content, " if (e != null && e.isReady()) {"); + line(content, " " + (genReturn ? "return " : "") + "e.performFromCache(graph, procedure);"); + if(!genReturn) line(content, " return;"); + line(content, " }"); + line(content, " }"); line(content, " " + (genReturn ? "return " : "") + clazz + ".computeForEach(graph, " + signature[1] + ", null, procedure);"); if(!genReturn) line(content, " return;"); line(content, " }"); @@ -65,6 +72,14 @@ public class CodeGen { line(content, "}"); line(content, ""); + String lower = Character.toLowerCase(clazz.charAt(0)) + clazz.substring(1); + + line(content, "private " + clazz + " peek" + clazz + "(" + signature[0] + ") {"); + line(content, " synchronized(" + lower +"Map) {"); + line(content, " return (" + clazz + ") " + lower + "Map.get(" + signature[1] + ");"); + line(content, " }"); + line(content, "}"); + line(content, ""); } public void generateRemove(StringBuilder content, String clazz, String[] signature) { @@ -144,6 +159,10 @@ public class CodeGen { content.append("public class QueryCache extends QueryCacheBase {\n"); content.append("\n"); + + line(content, "private static final boolean SINGLE = true;"); + content.append("\n"); + line(content,"public QueryCache(QuerySupport querySupport, int threads) {"); line(content," super(querySupport, threads);"); line(content,"}"); 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 ee65998d3..2fca451d6 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 @@ -19,6 +19,7 @@ import org.simantics.db.request.Read; public class QueryCache extends QueryCacheBase { + private static final boolean SINGLE = true; public QueryCache(QuerySupport querySupport, int threads) { super(querySupport, threads); } @@ -53,6 +54,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + Objects e = cache.peekObjects(r1,r2); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } Objects.computeForEach(graph, r1,r2, null, procedure); return; } @@ -67,6 +75,12 @@ public class QueryCache extends QueryCacheBase { } } + private Objects peekObjects(int r1, int r2) { + synchronized(objectsMap) { + return (Objects) objectsMap.get(r1,r2); + } + } + Statements getOrCreateStatements(ReadGraphImpl graph, int r1, int r2) throws DatabaseException { Statements existing = null; synchronized(statementsMap) { @@ -97,6 +111,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + Statements e = cache.peekStatements(r1,r2); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } Statements.computeForEach(graph, r1,r2, null, procedure); return; } @@ -111,6 +132,12 @@ public class QueryCache extends QueryCacheBase { } } + private Statements peekStatements(int r1, int r2) { + synchronized(statementsMap) { + return (Statements) statementsMap.get(r1,r2); + } + } + DirectObjects getOrCreateDirectObjects(ReadGraphImpl graph, int r1, int r2) throws DatabaseException { DirectObjects existing = null; synchronized(directObjectsMap) { @@ -141,6 +168,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + DirectObjects e = cache.peekDirectObjects(r1,r2); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } DirectObjects.computeForEach(graph, r1,r2, null, procedure); return; } @@ -155,6 +189,12 @@ public class QueryCache extends QueryCacheBase { } } + private DirectObjects peekDirectObjects(int r1, int r2) { + synchronized(directObjectsMap) { + return (DirectObjects) directObjectsMap.get(r1,r2); + } + } + RelationInfoQuery getOrCreateRelationInfoQuery(ReadGraphImpl graph, int r) throws DatabaseException { RelationInfoQuery existing = null; synchronized(relationInfoQueryMap) { @@ -185,6 +225,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + RelationInfoQuery e = cache.peekRelationInfoQuery(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } RelationInfoQuery.computeForEach(graph, r, null, procedure); return; } @@ -199,6 +246,12 @@ public class QueryCache extends QueryCacheBase { } } + private RelationInfoQuery peekRelationInfoQuery(int r) { + synchronized(relationInfoQueryMap) { + return (RelationInfoQuery) relationInfoQueryMap.get(r); + } + } + URIToResource getOrCreateURIToResource(ReadGraphImpl graph, String id) throws DatabaseException { URIToResource existing = null; synchronized(uRIToResourceMap) { @@ -229,6 +282,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + URIToResource e = cache.peekURIToResource(id); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } URIToResource.computeForEach(graph, id, null, procedure); return; } @@ -243,6 +303,12 @@ public class QueryCache extends QueryCacheBase { } } + private URIToResource peekURIToResource(String id) { + synchronized(uRIToResourceMap) { + return (URIToResource) uRIToResourceMap.get(id); + } + } + ValueQuery getOrCreateValueQuery(ReadGraphImpl graph, int r) throws DatabaseException { ValueQuery existing = null; synchronized(valueQueryMap) { @@ -273,6 +339,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + ValueQuery e = cache.peekValueQuery(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } ValueQuery.computeForEach(graph, r, null, procedure); return; } @@ -287,6 +360,12 @@ public class QueryCache extends QueryCacheBase { } } + private ValueQuery peekValueQuery(int r) { + synchronized(valueQueryMap) { + return (ValueQuery) valueQueryMap.get(r); + } + } + OrderedSet getOrCreateOrderedSet(ReadGraphImpl graph, int r) throws DatabaseException { OrderedSet existing = null; synchronized(orderedSetMap) { @@ -317,6 +396,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + OrderedSet e = cache.peekOrderedSet(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } OrderedSet.computeForEach(graph, r, null, procedure); return; } @@ -331,6 +417,12 @@ public class QueryCache extends QueryCacheBase { } } + private OrderedSet peekOrderedSet(int r) { + synchronized(orderedSetMap) { + return (OrderedSet) orderedSetMap.get(r); + } + } + PrincipalTypes getOrCreatePrincipalTypes(ReadGraphImpl graph, int r) throws DatabaseException { PrincipalTypes existing = null; synchronized(principalTypesMap) { @@ -361,6 +453,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + PrincipalTypes e = cache.peekPrincipalTypes(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } PrincipalTypes.computeForEach(graph, r, null, procedure); return; } @@ -375,6 +474,12 @@ public class QueryCache extends QueryCacheBase { } } + private PrincipalTypes peekPrincipalTypes(int r) { + synchronized(principalTypesMap) { + return (PrincipalTypes) principalTypesMap.get(r); + } + } + DirectPredicates getOrCreateDirectPredicates(ReadGraphImpl graph, int r) throws DatabaseException { DirectPredicates existing = null; synchronized(directPredicatesMap) { @@ -405,6 +510,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + DirectPredicates e = cache.peekDirectPredicates(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } DirectPredicates.computeForEach(graph, r, null, procedure); return; } @@ -419,6 +531,12 @@ public class QueryCache extends QueryCacheBase { } } + private DirectPredicates peekDirectPredicates(int r) { + synchronized(directPredicatesMap) { + return (DirectPredicates) directPredicatesMap.get(r); + } + } + Predicates getOrCreatePredicates(ReadGraphImpl graph, int r) throws DatabaseException { Predicates existing = null; synchronized(predicatesMap) { @@ -449,6 +567,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + Predicates e = cache.peekPredicates(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } Predicates.computeForEach(graph, r, null, procedure); return; } @@ -463,6 +588,12 @@ public class QueryCache extends QueryCacheBase { } } + private Predicates peekPredicates(int r) { + synchronized(predicatesMap) { + return (Predicates) predicatesMap.get(r); + } + } + ReadEntry getOrCreateReadEntry(ReadGraphImpl graph, Read r, boolean needsToBlock) throws DatabaseException { ReadEntry existing = null; synchronized(readEntryMap) { @@ -486,6 +617,7 @@ public class QueryCache extends QueryCacheBase { } return existing; } + void remove(ReadEntry entry) { synchronized(readEntryMap) { @@ -496,6 +628,12 @@ public class QueryCache extends QueryCacheBase { public static Object runnerReadEntry(ReadGraphImpl graph, Read r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure, final boolean needsToBlock) throws DatabaseException { QueryCache cache = graph.processor.cache; if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { + if (SINGLE) { + ReadEntry e = cache.peekReadEntry(r); + if (e != null && e.isReady()) { + return e.performFromCache(graph, procedure); + } + } return ReadEntry.computeForEach(graph, r, null, procedure); } ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(graph, r, needsToBlock); @@ -522,6 +660,13 @@ public class QueryCache extends QueryCacheBase { return result; } } + + + private ReadEntry peekReadEntry(Read r) { + synchronized(readEntryMap) { + return (ReadEntry) readEntryMap.get(r); + } + } AsyncReadEntry getOrCreateAsyncReadEntry(ReadGraphImpl graph, AsyncRead r, boolean needsToBlock) throws DatabaseException { AsyncReadEntry existing = null; @@ -546,6 +691,7 @@ public class QueryCache extends QueryCacheBase { } return existing; } + void remove(AsyncReadEntry entry) { synchronized(asyncReadEntryMap) { @@ -556,6 +702,12 @@ public class QueryCache extends QueryCacheBase { public static Object runnerAsyncReadEntry(ReadGraphImpl graph, AsyncRead r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure, final boolean needsToBlock) throws DatabaseException { QueryCache cache = graph.processor.cache; if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { + if (SINGLE) { + AsyncReadEntry e = cache.peekAsyncReadEntry(r); + if (e != null && e.isReady()) { + return e.performFromCache(graph, procedure); + } + } return AsyncReadEntry.computeForEach(graph, r, null, procedure, needsToBlock); } AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(graph, r, needsToBlock); @@ -582,6 +734,13 @@ public class QueryCache extends QueryCacheBase { return result; } } + + + private AsyncReadEntry peekAsyncReadEntry(AsyncRead r) { + synchronized(asyncReadEntryMap) { + return (AsyncReadEntry) asyncReadEntryMap.get(r); + } + } Types getOrCreateTypes(ReadGraphImpl graph, int r) throws DatabaseException { Types existing = null; @@ -613,6 +772,13 @@ public class QueryCache extends QueryCacheBase { 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)) { + if (SINGLE) { + Types e = cache.peekTypes(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } Types.computeForEach(graph, r, null, procedure); return; } @@ -627,6 +793,12 @@ public class QueryCache extends QueryCacheBase { } } + private Types peekTypes(int r) { + synchronized(typesMap) { + return (Types) typesMap.get(r); + } + } + ChildMap getOrCreateChildMap(ReadGraphImpl graph, int r) throws DatabaseException { ChildMap existing = null; synchronized(childMapMap) { @@ -657,6 +829,13 @@ public class QueryCache extends QueryCacheBase { public static void runnerChildMap(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)) { + if (SINGLE) { + ChildMap e = cache.peekChildMap(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } ChildMap.computeForEach(graph, r, null, procedure); return; } @@ -671,6 +850,12 @@ public class QueryCache extends QueryCacheBase { } } + private ChildMap peekChildMap(int r) { + synchronized(childMapMap) { + return (ChildMap) childMapMap.get(r); + } + } + TypeHierarchy getOrCreateTypeHierarchy(ReadGraphImpl graph, int r) throws DatabaseException { TypeHierarchy existing = null; synchronized(typeHierarchyMap) { @@ -701,6 +886,13 @@ public class QueryCache extends QueryCacheBase { public static void runnerTypeHierarchy(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)) { + if (SINGLE) { + TypeHierarchy e = cache.peekTypeHierarchy(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } TypeHierarchy.computeForEach(graph, r, null, procedure); return; } @@ -715,6 +907,12 @@ public class QueryCache extends QueryCacheBase { } } + private TypeHierarchy peekTypeHierarchy(int r) { + synchronized(typeHierarchyMap) { + return (TypeHierarchy) typeHierarchyMap.get(r); + } + } + SuperTypes getOrCreateSuperTypes(ReadGraphImpl graph, int r) throws DatabaseException { SuperTypes existing = null; synchronized(superTypesMap) { @@ -745,6 +943,13 @@ public class QueryCache extends QueryCacheBase { public static void runnerSuperTypes(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)) { + if (SINGLE) { + SuperTypes e = cache.peekSuperTypes(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } SuperTypes.computeForEach(graph, r, null, procedure); return; } @@ -759,6 +964,12 @@ public class QueryCache extends QueryCacheBase { } } + private SuperTypes peekSuperTypes(int r) { + synchronized(superTypesMap) { + return (SuperTypes) superTypesMap.get(r); + } + } + SuperRelations getOrCreateSuperRelations(ReadGraphImpl graph, int r) throws DatabaseException { SuperRelations existing = null; synchronized(superRelationsMap) { @@ -789,6 +1000,13 @@ public class QueryCache extends QueryCacheBase { public static void runnerSuperRelations(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)) { + if (SINGLE) { + SuperRelations e = cache.peekSuperRelations(r); + if (e != null && e.isReady()) { + e.performFromCache(graph, procedure); + return; + } + } SuperRelations.computeForEach(graph, r, null, procedure); return; } @@ -803,6 +1021,12 @@ public class QueryCache extends QueryCacheBase { } } + private SuperRelations peekSuperRelations(int r) { + synchronized(superRelationsMap) { + return (SuperRelations) superRelationsMap.get(r); + } + } + AssertedPredicates getOrCreateAssertedPredicates(ReadGraphImpl graph, int r) throws DatabaseException { AssertedPredicates existing = null; synchronized(assertedPredicatesMap) { @@ -843,6 +1067,12 @@ public class QueryCache extends QueryCacheBase { } } + private AssertedPredicates peekAssertedPredicates(int r) { + synchronized(assertedPredicatesMap) { + return (AssertedPredicates) assertedPredicatesMap.get(r); + } + } + AssertedStatements getOrCreateAssertedStatements(ReadGraphImpl graph, int r1, int r2) throws DatabaseException { AssertedStatements existing = null; synchronized(assertedStatementsMap) { @@ -883,6 +1113,12 @@ public class QueryCache extends QueryCacheBase { } } + private AssertedStatements peekAssertedStatements(int r1, int r2) { + synchronized(assertedStatementsMap) { + return (AssertedStatements) assertedStatementsMap.get(r1,r2); + } + } + DirectSuperRelations getOrCreateDirectSuperRelations(ReadGraphImpl graph, int r) throws DatabaseException { DirectSuperRelations existing = null; synchronized(directSuperRelationsMap) { @@ -923,6 +1159,12 @@ public class QueryCache extends QueryCacheBase { } } + private DirectSuperRelations peekDirectSuperRelations(int r) { + synchronized(directSuperRelationsMap) { + return (DirectSuperRelations) directSuperRelationsMap.get(r); + } + } + MultiReadEntry getOrCreateMultiReadEntry(ReadGraphImpl graph, MultiRead r) throws DatabaseException { MultiReadEntry existing = null; synchronized(multiReadEntryMap) { @@ -963,6 +1205,12 @@ public class QueryCache extends QueryCacheBase { } } + private MultiReadEntry peekMultiReadEntry(MultiRead r) { + synchronized(multiReadEntryMap) { + return (MultiReadEntry) multiReadEntryMap.get(r); + } + } + AsyncMultiReadEntry getOrCreateAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead r) throws DatabaseException { AsyncMultiReadEntry existing = null; synchronized(asyncMultiReadEntryMap) { @@ -1003,6 +1251,12 @@ public class QueryCache extends QueryCacheBase { } } + private AsyncMultiReadEntry peekAsyncMultiReadEntry(AsyncMultiRead r) { + synchronized(asyncMultiReadEntryMap) { + return (AsyncMultiReadEntry) asyncMultiReadEntryMap.get(r); + } + } + ExternalReadEntry getOrCreateExternalReadEntry(ReadGraphImpl graph, ExternalRead r) throws DatabaseException { ExternalReadEntry existing = null; synchronized(externalReadEntryMap) { @@ -1023,6 +1277,7 @@ public class QueryCache extends QueryCacheBase { if(existing.isPending()) waitPending(graph, existing); return existing; } + void remove(ExternalReadEntry entry) { synchronized(externalReadEntryMap) { @@ -1043,4 +1298,10 @@ public class QueryCache extends QueryCacheBase { } } + private ExternalReadEntry peekExternalReadEntry(ExternalRead r) { + synchronized(externalReadEntryMap) { + return (ExternalReadEntry) externalReadEntryMap.get(r); + } + } + }