Changeset 281

Timestamp:

06/02/08 10:32:04 (16 years ago)

Author:

gkronber

Message:

ticket #155
operations that failed at a grid-client are pushed back onto the stack again to force local execution. If they fail locally as well the user will get the usual error dialog and can fix the bug (and save/load the engine as usual).

Location:

trunk/sources/HeuristicLab.DistributedEngine

Files:

• DistributedEngine.cs (modified) (3 diffs)
• JobManager.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.DistributedEngine/DistributedEngine.cs

@@ -99 +99 @@
             // 4) for each parallel job attach only the sub-scope that this operation uses
             // 5) after starting all parallel jobs restore the whole scope-tree
-            IScope parentScope = FindParentScope(GlobalScope, compositeOperation);
+            IScope parentScope = FindParentScope(GlobalScope, ((AtomicOperation)compositeOperation.Operations[0]).Scope);
             List<IList<IScope>> prunedScopes = new List<IList<IScope>>();
             PruneToParentScope(GlobalScope, parentScope, prunedScopes);
@@ -130 +130 @@
             // retrieve results and merge into scope-tree
             foreach(AtomicOperation parOperation in compositeOperation.Operations) {
-              IScope result = jobManager.EndExecuteOperation(parOperation);
-              MergeScope(parOperation.Scope, result);
+              ProcessingEngine resultEngine = jobManager.EndExecuteOperation(parOperation);
+              if(resultEngine.ExecutionStack.Count > 0) {
+                // when there are operations left in the execution stack it means that the engine has been aborted
+                // for unkown reason. Probably there was a problem at the client, so we can try to execute the steps locally.
+                // If they also fail the (local) distributued-engine will be aborted and we will see an error-message.
+                // Solution: We could push all waiting operations in the execution stack of the result engine into our own
+                // execution stack, but this is not easy because we have to change the operations to point to the 
+                // original scopes instead of the new scopes (created while deserializing the processing engine).
+                // Instead just push the original parallel operation back on the stack to force local execution.
+                ExecutionStack.Push(parOperation);
+              } else {
+                // if everything went fine we can merge the results into our local scope-tree
+                MergeScope(parOperation.Scope, resultEngine.InitialOperation.Scope);
+              }
             }
           } catch(Exception e) {
@@ -181 +193 @@
     }
 
-    private IScope FindParentScope(IScope currentScope, CompositeOperation compositeOperation) {
-      AtomicOperation currentOperation = (AtomicOperation)compositeOperation.Operations[0];
-      if(currentScope.SubScopes.Contains(currentOperation.Scope)) return currentScope;
+    private IScope FindParentScope(IScope currentScope, IScope childScope) {
+      if(currentScope.SubScopes.Contains(childScope)) return currentScope;
       foreach(IScope subScope in currentScope.SubScopes) {
-        IScope result = FindParentScope(subScope, compositeOperation);
+        IScope result = FindParentScope(subScope, childScope);
         if(result != null) return result;
       }

trunk/sources/HeuristicLab.DistributedEngine/JobManager.cs

@@ -125 +125 @@
     }
 
-    public IScope EndExecuteOperation(AtomicOperation operation) {
+    public ProcessingEngine EndExecuteOperation(AtomicOperation operation) {
       byte[] zippedResult = null;
       lock(dictionaryLock) {
@@ -133 +133 @@
       // restore the engine 
       using(GZipStream stream = new GZipStream(new MemoryStream(zippedResult), CompressionMode.Decompress)) {
-        ProcessingEngine resultEngine = (ProcessingEngine)PersistenceManager.Load(stream);
-        return resultEngine.InitialOperation.Scope;
+        return (ProcessingEngine)PersistenceManager.Load(stream);
       }      
     }