X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.db.impl%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fimpl%2Fquery%2FAsyncReadEntry.java;h=72582ee605802bfe32fac38d10119f6200602586;hb=159d04234f7fbf7554910a154b29a5dd7bbc6068;hp=f409b40c8c330069023ede4686c6363ba76ae948;hpb=782843a248c4f70d28e8146098f9a77977cc6b3c;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/AsyncReadEntry.java b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/AsyncReadEntry.java
index f409b40c8..72582ee60 100644
--- a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/AsyncReadEntry.java
+++ b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/AsyncReadEntry.java
@@ -11,15 +11,18 @@
  *******************************************************************************/
 package org.simantics.db.impl.query;
 
+import org.simantics.databoard.Bindings;
 import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.DevelopmentKeys;
 import org.simantics.db.exception.DatabaseException;
 import org.simantics.db.impl.BlockingAsyncProcedure;
-import org.simantics.db.impl.DebugPolicy;
 import org.simantics.db.impl.graph.AsyncBarrierImpl;
+import org.simantics.db.impl.graph.BarrierTracing;
 import org.simantics.db.impl.graph.ReadGraphImpl;
 import org.simantics.db.impl.query.QueryProcessor.SessionTask;
 import org.simantics.db.procedure.AsyncProcedure;
 import org.simantics.db.request.AsyncRead;
+import org.simantics.utils.Development;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -27,22 +30,25 @@ final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> i
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AsyncReadEntry.class);
 
-    protected AsyncRead<T> request;
+    protected AsyncRead<T> id;
 
     AsyncReadEntry(AsyncRead<T> request) {
-        this.request = request;
-        if (DebugPolicy.QUERY_STATE)
-            System.out.println("[QUERY STATE]: created " + this);
+        this.id = request;
+		if (Development.DEVELOPMENT) {
+			if(Development.<Boolean>getProperty(DevelopmentKeys.CACHE_ENTRY_STATE, Bindings.BOOLEAN)) {
+		        System.err.println("[QUERY STATE]: created " + this);
+			}
+		}
     }
 
     @Override
     int makeHash() {
-        return request.hashCode();
+        return id.hashCode();
     }
 
     @Override
     public Object getOriginalRequest() {
-        return request;
+        return id;
     }
 
     @Override
@@ -84,9 +90,9 @@ final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> i
                             except(t);
                         }
 
-                    }, request);
+                    }, id);
 
-                    request.perform(graph, proc);
+                    id.perform(graph, proc);
 
                     proc.get();
 
@@ -103,17 +109,17 @@ final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> i
 
             @Override
             public int type() {
-                return request.getFlags();
+                return id.getFlags();
             }
 
             @Override
             public String toString() {
-                if (request == null)
+                if (id == null)
                     return "DISCARDED";
                 else if (isExcepted())
-                    return request.toString() + " " + getResult();
+                    return id.toString() + " " + getResult();
                 else
-                    return request.toString() + " " + statusOrException;
+                    return id.toString() + " " + statusOrException;
             }
 
         };
@@ -152,12 +158,13 @@ final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> i
         AsyncProcedure<T> procedure = entry != null ? entry : procedure_;
 
         ReadGraphImpl queryGraph = graph.withParent(entry);
+        queryGraph.asyncBarrier.inc();
         
         BlockingAsyncProcedure<T> proc = new BlockingAsyncProcedure<>(queryGraph.asyncBarrier, graph, null, request);
         
         class AsyncTask extends SessionTask {
 
-        	int counter = 0;
+            int counter = 0;
             T result;
             DatabaseException exception;
             
@@ -166,44 +173,58 @@ final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> i
             }
 
             @Override
-            public void run(int thread) {
+            public void run0(int thread) {
                 if(needsToBlock) proc.waitBarrier();
                 if(proc.isDone()) {
+                    ReadGraphImpl executeGraph = graph.withParent(graph.parent);
+                    executeGraph.asyncBarrier.inc();
                     try {
                         result = (T)proc.get();
-                        if(procedure != null) procedure.execute(graph, result);
+                        if(procedure != null) {
+                            procedure.execute(executeGraph, result);
+                        }
                     } catch (DatabaseException e) {
-                        if(procedure != null) procedure.exception(graph, e);
+                        if(procedure != null) procedure.exception(executeGraph, e);
                         exception = e;
                     } catch (Throwable t) {
                         DatabaseException dbe = new DatabaseException(t);
-                        if(procedure != null) procedure.exception(graph, dbe);
+                        if(procedure != null) procedure.exception(executeGraph, dbe);
                         exception = dbe;
                     } finally {
-                        if (entry != null)
-                            entry.performFromCache(graph, procedure_);
+                        if (entry != null) {
+                            // This does not throw
+                            entry.performFromCache(executeGraph, procedure_);
+                        }
+                        executeGraph.asyncBarrier.dec();
+                        executeGraph.asyncBarrier.waitBarrier(procedure, executeGraph);
                     }
                 } else {
-                	if(counter++ > 10000) {
-                	 	AsyncBarrierImpl.printReverse(queryGraph.asyncBarrier, 2);
-                	 	AsyncBarrierImpl caller = queryGraph.asyncBarrier.caller;
-                	 	while(caller != null) {
-                	 		System.err.println("called by " + AsyncBarrierImpl.report(caller));
-                	 		caller = caller.caller;
-                	 	}
-                	 	for(AsyncBarrierImpl ab : AsyncBarrierImpl.debuggerMap.keySet()) {
-                    	 	AsyncBarrierImpl.printReverse(ab, 2);
-                	 	}
-                	 	throw new IllegalStateException("Eternal loop in queries.");
-                	}
-                    graph.processor.schedule(this);            
+                    if(counter++ > 10000) {
+                        if(BarrierTracing.BOOKKEEPING) {
+                            AsyncBarrierImpl.printReverse(queryGraph.asyncBarrier, 2);
+                            AsyncBarrierImpl caller = queryGraph.asyncBarrier.caller;
+                            while(caller != null) {
+                                System.err.println("called by " + AsyncBarrierImpl.report(caller));
+                                caller = caller.caller;
+                            }
+                            for(AsyncBarrierImpl ab : BarrierTracing.debuggerMap.keySet()) {
+                                AsyncBarrierImpl.printReverse(ab, 2);
+                            }
+                        }
+                        throw new IllegalStateException("Eternal loop in queries.");
+                    }
+                    graph.processor.schedule(new AsyncTask(graph));
                 }
             }
             
         }
-        
-        request.perform(queryGraph, proc);
-        
+
+        try {
+            request.perform(queryGraph, proc);
+        } finally {
+            queryGraph.asyncBarrier.dec();
+        }
+
         AsyncTask task = new AsyncTask(graph);
 
         if(needsToBlock) task.run(0);
@@ -212,7 +233,7 @@ final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> i
             graph.processor.schedule(task);
             return null;
         }
-        
+
         if(task.exception != null) throw task.exception;
         else return task.result;
 
@@ -221,11 +242,11 @@ final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> i
     @Override
     public String toString() {
         if (isDiscarded())
-            return "DISCARDED " + request.toString();
+            return "DISCARDED " + id.toString();
         else if (isExcepted())
-            return request.toString() + " " + getResult();
+            return id.toString() + " " + getResult();
         else
-            return request.toString() + " " + statusOrException;
+            return id.toString() + " " + statusOrException;
     }
 
     @Override