Index: /trunk/sources/HeuristicLab.DistributedEngine/DistributedEngine.cs
===================================================================
--- /trunk/sources/HeuristicLab.DistributedEngine/DistributedEngine.cs	(revision 218)
+++ /trunk/sources/HeuristicLab.DistributedEngine/DistributedEngine.cs	(revision 219)
@@ -30,13 +30,12 @@
 using System.IO;
 using System.IO.Compression;
+using HeuristicLab.PluginInfrastructure;
+using System.Windows.Forms;
 
 namespace HeuristicLab.DistributedEngine {
   public class DistributedEngine : EngineBase, IEditable {
-    private IGridServer server;
-    private Dictionary<Guid, AtomicOperation> engineOperations = new Dictionary<Guid, AtomicOperation>();
-    private List<Guid> runningEngines = new List<Guid>();
+    private JobManager jobManager;
+    private CompositeOperation waitingOperations;
     private string serverAddress;
-    private bool cancelRequested;
-    private CompositeOperation waitingOperations;
     public string ServerAddress {
       get { return serverAddress; }
@@ -45,9 +44,4 @@
           serverAddress = value;
         }
-      }
-    }
-    public override bool Terminated {
-      get {
-        return myExecutionStack.Count == 0 && runningEngines.Count == 0 && waitingOperations==null;
       }
     }
@@ -66,12 +60,6 @@
 
     public override void Execute() {
-      NetTcpBinding binding = new NetTcpBinding();
-      binding.MaxReceivedMessageSize = 100000000; // 100Mbytes
-      binding.ReaderQuotas.MaxStringContentLength = 100000000; // also 100M chars
-      binding.ReaderQuotas.MaxArrayLength = 100000000; // also 100M elements;
-      binding.Security.Mode = SecurityMode.None;
-      ChannelFactory<IGridServer> factory = new ChannelFactory<IGridServer>(binding);
-      server = factory.CreateChannel(new EndpointAddress(serverAddress));
-
+      if(jobManager == null) this.jobManager = new JobManager(serverAddress);
+      jobManager.Reset();
       base.Execute();
     }
@@ -81,99 +69,38 @@
     }
 
-    public override void Abort() {
-      lock(runningEngines) {
-        cancelRequested = true;
-        foreach(Guid engineGuid in runningEngines) {
-          server.AbortEngine(engineGuid);
+    protected override void ProcessNextOperation() {
+      IOperation operation = myExecutionStack.Pop();
+      if(operation is AtomicOperation) {
+        AtomicOperation atomicOperation = (AtomicOperation)operation;
+        IOperation next = null;
+        try {
+          next = atomicOperation.Operator.Execute(atomicOperation.Scope);
+        } catch(Exception ex) {
+          // push operation on stack again
+          myExecutionStack.Push(atomicOperation);
+          Abort();
+          ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex); });
         }
-      }
-    }
-    public override void Reset() {
-      base.Reset();
-      engineOperations.Clear();
-      runningEngines.Clear();
-      cancelRequested = false;
-    }
-
-    protected override void ProcessNextOperation() {
-      lock(runningEngines) {
-        if(runningEngines.Count == 0 && cancelRequested) {
-          base.Abort();
-          cancelRequested = false;
-          if(waitingOperations != null && waitingOperations.Operations.Count != 0) {
-            myExecutionStack.Push(waitingOperations);
-            waitingOperations = null;
+        if(next != null)
+          myExecutionStack.Push(next);
+        OnOperationExecuted(atomicOperation);
+        if(atomicOperation.Operator.Breakpoint) Abort();
+      } else if(operation is CompositeOperation) {
+        CompositeOperation compositeOperation = (CompositeOperation)operation;
+        if(compositeOperation.ExecuteInParallel) {
+          WaitHandle[] waithandles = new WaitHandle[compositeOperation.Operations.Count];
+          int i = 0;
+          foreach(AtomicOperation parOperation in compositeOperation.Operations) {
+            waithandles[i++] = jobManager.BeginExecuteOperation(OperatorGraph, GlobalScope, parOperation);
           }
-          return;
-        }
-        if(runningEngines.Count != 0) {
-          Guid engineGuid = runningEngines[0];
-          byte[] resultXml = server.TryEndExecuteEngine(engineGuid, 100);
-          if(resultXml != null) {
-            GZipStream stream = new GZipStream(new MemoryStream(resultXml), CompressionMode.Decompress);
-            ProcessingEngine resultEngine = (ProcessingEngine)PersistenceManager.Load(stream);
-            IScope oldScope = engineOperations[engineGuid].Scope;
-            oldScope.Clear();
-            foreach(IVariable variable in resultEngine.InitialOperation.Scope.Variables) {
-              oldScope.AddVariable(variable);
-            }
-            foreach(IScope subScope in resultEngine.InitialOperation.Scope.SubScopes) {
-              oldScope.AddSubScope(subScope);
-            }
-            OnOperationExecuted(engineOperations[engineGuid]);
-
-            if(cancelRequested & resultEngine.ExecutionStack.Count != 0) {
-              if(waitingOperations == null) {
-                waitingOperations = new CompositeOperation();
-                waitingOperations.ExecuteInParallel = false;
-              }
-              CompositeOperation task = new CompositeOperation();
-              while(resultEngine.ExecutionStack.Count > 0) {
-                AtomicOperation oldOperation = (AtomicOperation)resultEngine.ExecutionStack.Pop();
-                if(oldOperation.Scope == resultEngine.InitialOperation.Scope) {
-                  oldOperation = new AtomicOperation(oldOperation.Operator, oldScope);
-                }
-                task.AddOperation(oldOperation);
-              }
-              waitingOperations.AddOperation(task);
-            }
-            runningEngines.Remove(engineGuid);
-            engineOperations.Remove(engineGuid);
+          WaitHandle.WaitAll(waithandles);
+          if(jobManager.Exception != null) {
+            myExecutionStack.Push(compositeOperation);
+            Abort();
+            ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(jobManager.Exception); });
           }
-          return;
-        }
-        IOperation operation = myExecutionStack.Pop();
-        if(operation is AtomicOperation) {
-          AtomicOperation atomicOperation = (AtomicOperation)operation;
-          IOperation next = null;
-          try {
-            next = atomicOperation.Operator.Execute(atomicOperation.Scope);
-          } catch(Exception ex) {
-            // push operation on stack again
-            myExecutionStack.Push(atomicOperation);
-            Abort();
-            ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex); });
-          }
-          if(next != null)
-            myExecutionStack.Push(next);
-          OnOperationExecuted(atomicOperation);
-          if(atomicOperation.Operator.Breakpoint) Abort();
-        } else if(operation is CompositeOperation) {
-          CompositeOperation compositeOperation = (CompositeOperation)operation;
-          if(compositeOperation.ExecuteInParallel) {
-            foreach(AtomicOperation parOperation in compositeOperation.Operations) {
-              ProcessingEngine engine = new ProcessingEngine(OperatorGraph, GlobalScope, parOperation); // OperatorGraph not needed?
-              MemoryStream memStream = new MemoryStream();
-              GZipStream stream = new GZipStream(memStream, CompressionMode.Compress, true);
-              PersistenceManager.Save(engine, stream);
-              stream.Close();
-              Guid currentEngineGuid = server.BeginExecuteEngine(memStream.ToArray());
-              runningEngines.Add(currentEngineGuid);
-              engineOperations[currentEngineGuid] = parOperation;
-            }
-          } else {
-            for(int i = compositeOperation.Operations.Count - 1; i >= 0; i--)
-              myExecutionStack.Push(compositeOperation.Operations[i]);
-          }
+        } else {
+          for(int i = compositeOperation.Operations.Count - 1; i >= 0; i--)
+            myExecutionStack.Push(compositeOperation.Operations[i]);
         }
       }
Index: /trunk/sources/HeuristicLab.DistributedEngine/HeuristicLab.DistributedEngine.csproj
===================================================================
--- /trunk/sources/HeuristicLab.DistributedEngine/HeuristicLab.DistributedEngine.csproj	(revision 218)
+++ /trunk/sources/HeuristicLab.DistributedEngine/HeuristicLab.DistributedEngine.csproj	(revision 219)
@@ -50,4 +50,5 @@
   <ItemGroup>
     <Compile Include="HeuristicLabDistributedEnginePlugin.cs" />
+    <Compile Include="JobManager.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="DistributedEngine.cs" />
Index: /trunk/sources/HeuristicLab.DistributedEngine/JobManager.cs
===================================================================
--- /trunk/sources/HeuristicLab.DistributedEngine/JobManager.cs	(revision 219)
+++ /trunk/sources/HeuristicLab.DistributedEngine/JobManager.cs	(revision 219)
@@ -0,0 +1,129 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ServiceModel;
+using HeuristicLab.Grid;
+using System.Threading;
+using HeuristicLab.Core;
+using System.IO;
+using System.IO.Compression;
+using System.Windows.Forms;
+
+namespace HeuristicLab.DistributedEngine {
+  class JobManager {
+    private IGridServer server;
+    private string address;
+    private Dictionary<Guid, AtomicOperation> engineOperations = new Dictionary<Guid, AtomicOperation>();
+    private Dictionary<Guid, byte[]> runningEngines = new Dictionary<Guid, byte[]>();
+    private Dictionary<Guid, ManualResetEvent> waithandles = new Dictionary<Guid, ManualResetEvent>();
+    private object locker = new object();
+    private const int MAX_RESTARTS = 5;
+    private Exception exception;
+    public Exception Exception {
+      get { return exception; }
+    }
+
+    public JobManager(string address) {
+      this.address = address;
+    }
+
+    internal void Reset() {
+      lock(locker) {
+        // open a new channel
+        NetTcpBinding binding = new NetTcpBinding();
+        binding.MaxReceivedMessageSize = 100000000; // 100Mbytes
+        binding.ReaderQuotas.MaxStringContentLength = 100000000; // also 100M chars
+        binding.ReaderQuotas.MaxArrayLength = 100000000; // also 100M elements;
+        binding.Security.Mode = SecurityMode.None;
+        ChannelFactory<IGridServer> factory = new ChannelFactory<IGridServer>(binding);
+        server = factory.CreateChannel(new EndpointAddress(address));
+
+        foreach(WaitHandle wh in waithandles.Values) wh.Close();
+        waithandles.Clear();
+        engineOperations.Clear();
+        runningEngines.Clear();
+        exception = null;
+      }
+    }
+
+    public WaitHandle BeginExecuteOperation(IOperatorGraph operatorGraph, IScope globalScope, AtomicOperation operation) {
+      ProcessingEngine engine = new ProcessingEngine(operatorGraph, globalScope, operation); // OperatorGraph not needed?
+      MemoryStream memStream = new MemoryStream();
+      GZipStream stream = new GZipStream(memStream, CompressionMode.Compress, true);
+      PersistenceManager.Save(engine, stream); // Careful! Make sure that persistence is thread-safe!
+      stream.Close();
+      Guid currentEngineGuid = server.BeginExecuteEngine(memStream.ToArray());
+      lock(locker) {
+        runningEngines[currentEngineGuid] = memStream.ToArray();
+        engineOperations[currentEngineGuid] = operation;
+        waithandles[currentEngineGuid] = new ManualResetEvent(false);
+        ThreadPool.QueueUserWorkItem(new WaitCallback(TryGetResult), currentEngineGuid);
+      }
+      return waithandles[currentEngineGuid];
+    }
+
+    private void TryGetResult(object state) {
+      Guid engineGuid = (Guid)state;
+      int restartCounter = 0;
+      do {
+        try {
+          byte[] resultXml = server.TryEndExecuteEngine(engineGuid, 100);
+          if(resultXml != null) {
+            // restore the engine 
+            GZipStream stream = new GZipStream(new MemoryStream(resultXml), CompressionMode.Decompress);
+            ProcessingEngine resultEngine = (ProcessingEngine)PersistenceManager.Load(stream);
+
+            // merge the results
+            IScope oldScope = engineOperations[engineGuid].Scope;
+            oldScope.Clear();
+            foreach(IVariable variable in resultEngine.InitialOperation.Scope.Variables) {
+              oldScope.AddVariable(variable);
+            }
+            foreach(IScope subScope in resultEngine.InitialOperation.Scope.SubScopes) {
+              oldScope.AddSubScope(subScope);
+            }
+            foreach(KeyValuePair<string, string> alias in resultEngine.InitialOperation.Scope.Aliases) {
+              oldScope.AddAlias(alias.Key, alias.Value);
+            }
+
+            lock(locker) {
+              // signal the wait handle and clean up then return
+              waithandles[engineGuid].Set();
+              engineOperations.Remove(engineGuid);
+              waithandles.Remove(engineGuid);
+              runningEngines.Remove(engineGuid);
+            }
+            return;
+          } else {
+            // check if the server is still working on the job
+            JobState jobState = server.JobState(engineGuid);
+            if(jobState == JobState.Unkown) {
+              // restart job
+              byte[] packedEngine;
+              lock(locker) {
+                packedEngine = runningEngines[engineGuid];
+              }
+              server.BeginExecuteEngine(packedEngine);
+              restartCounter++;
+            }
+          }
+        } catch(Exception e) {
+          // catch all exceptions set an exception flag, signal the wait-handle and exit the routine
+          this.exception = new Exception("There was a problem with parallel execution", e);
+          waithandles[engineGuid].Set();
+          return;
+        }
+
+        // when we reach a maximum amount of restarts => signal the wait-handle and set a flag that there was a problem
+        if(restartCounter > MAX_RESTARTS) {
+          this.exception = new Exception("Maximal number of parallel job restarts reached");
+          waithandles[engineGuid].Set();
+          return;
+        }
+
+        Thread.Sleep(TimeSpan.FromSeconds(10.0));
+      } while(true);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Grid/ClientForm.cs
===================================================================
--- /trunk/sources/HeuristicLab.Grid/ClientForm.cs	(revision 218)
+++ /trunk/sources/HeuristicLab.Grid/ClientForm.cs	(revision 219)
@@ -46,5 +46,4 @@
     private ProcessingEngine currentEngine;
     private string clientUrl;
-    private object locker = new object();
 
     public ClientForm() {
@@ -62,8 +61,8 @@
 
       // windows XP returns the external ip on index 0 while windows vista returns the external ip on index 2
-      if (System.Environment.OSVersion.Version.Major >= 6) {
-        clientUrl = "net.tcp://" + Dns.GetHostAddresses(Dns.GetHostName())[2] + ":" + clientPort.Text +"/Grid/Client";
+      if(System.Environment.OSVersion.Version.Major >= 6) {
+        clientUrl = "net.tcp://" + Dns.GetHostAddresses(Dns.GetHostName())[2] + ":" + clientPort.Text + "/Grid/Client";
       } else {
-        clientUrl = "net.tcp://" + Dns.GetHostAddresses(Dns.GetHostName())[0] + ":" + clientPort.Text +"/Grid/Client";
+        clientUrl = "net.tcp://" + Dns.GetHostAddresses(Dns.GetHostName())[0] + ":" + clientPort.Text + "/Grid/Client";
       }
 
@@ -87,5 +86,5 @@
         statusTextBox.Text = "Waiting for engine";
 
-      } catch (CommunicationException ex) {
+      } catch(CommunicationException ex) {
         MessageBox.Show("Exception while connecting to the server: " + ex.Message);
         clientHost.Abort();
@@ -106,8 +105,8 @@
 
     private void fetchOperationTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) {
-      lock(locker) {
-        byte[] engineXml;
-        fetchOperationTimer.Stop();
-        if(engineStore.TryTakeEngine(clientUrl, out currentGuid, out engineXml)) {
+      byte[] engineXml;
+      fetchOperationTimer.Stop();
+      try {
+        if(engineStore.TryTakeEngine(out currentGuid, out engineXml)) {
           currentEngine = RestoreEngine(engineXml);
           if(InvokeRequired) { Invoke((MethodInvoker)delegate() { statusTextBox.Text = "Executing engine"; }); } else statusTextBox.Text = "Executing engine";
@@ -126,14 +125,16 @@
           fetchOperationTimer.Start();
         }
+      } catch(Exception ex) {
+        currentEngine = null;
+        currentGuid = Guid.Empty;
+        fetchOperationTimer.Interval = 5000;
+        fetchOperationTimer.Start();
       }
     }
     public void Abort(Guid guid) {
-      lock(locker) {
-        if(!IsRunningEngine(guid)) return;
-        currentEngine.Abort();
-      }
+      throw new NotSupportedException();
     }
     public bool IsRunningEngine(Guid guid) {
-      return currentGuid == guid;
+      throw new NotSupportedException();
     }
     private ProcessingEngine RestoreEngine(byte[] engine) {
Index: /trunk/sources/HeuristicLab.Grid/EngineStore.cs
===================================================================
--- /trunk/sources/HeuristicLab.Grid/EngineStore.cs	(revision 218)
+++ /trunk/sources/HeuristicLab.Grid/EngineStore.cs	(revision 219)
@@ -31,8 +31,7 @@
     private List<Guid> engineList;
     private Dictionary<Guid, byte[]> waitingEngines;
-    private Dictionary<Guid, byte[]> runningEngines;
     private Dictionary<Guid, ManualResetEvent> waitHandles;
     private Dictionary<Guid, byte[]> results;
-    private Dictionary<Guid, string> runningClients;
+    private Dictionary<Guid, DateTime> resultDate;
     private object bigLock;
     private ChannelFactory<IClient> clientChannelFactory;
@@ -45,5 +44,5 @@
     public int RunningJobs {
       get {
-        return runningEngines.Count;
+        return waitHandles.Count;
       }
     }
@@ -58,8 +57,7 @@
       engineList = new List<Guid>();
       waitingEngines = new Dictionary<Guid, byte[]>();
-      runningEngines = new Dictionary<Guid, byte[]>();
-      runningClients = new Dictionary<Guid, string>();
       waitHandles = new Dictionary<Guid, ManualResetEvent>();
       results = new Dictionary<Guid, byte[]>();
+      resultDate = new Dictionary<Guid, DateTime>();
       bigLock = new object();
 
@@ -73,5 +71,5 @@
     }
 
-    public bool TryTakeEngine(string clientUrl, out Guid guid, out byte[] engine) {
+    public bool TryTakeEngine(out Guid guid, out byte[] engine) {
       lock(bigLock) {
         if(engineList.Count == 0) {
@@ -84,6 +82,4 @@
           engine = waitingEngines[guid];
           waitingEngines.Remove(guid);
-          runningEngines[guid] = engine;
-          runningClients[guid] = clientUrl;
           return true;
         }
@@ -93,11 +89,26 @@
     public void StoreResult(Guid guid, byte[] result) {
       lock(bigLock) {
-        if(!runningEngines.ContainsKey(guid)) return; // ignore result when the engine is not known to be running
-
-        runningEngines.Remove(guid);
-        runningClients.Remove(guid);
+        // clear old results
+        List<Guid> expiredResults = FindExpiredResults(DateTime.Now.AddHours(-1.0));
+        foreach(Guid expiredGuid in expiredResults) {
+          results.Remove(expiredGuid);
+          waitHandles.Remove(expiredGuid);
+          resultDate.Remove(expiredGuid);
+        }
+        // add the new result
         results[guid] = result;
+        resultDate[guid] = DateTime.Now;
         waitHandles[guid].Set();
       }
+    }
+
+    private List<Guid> FindExpiredResults(DateTime expirationDate) {
+      List<Guid> expiredResults = new List<Guid>();
+      foreach(Guid guid in results.Keys) {
+        if(resultDate[guid] < expirationDate) {
+          expiredResults.Add(guid);
+        }
+      }
+      return expiredResults;
     }
 
@@ -113,19 +124,33 @@
       return GetResult(guid, System.Threading.Timeout.Infinite);
     }
+
     internal byte[] GetResult(Guid guid, int timeout) {
       lock(bigLock) {
-        if(waitHandles.ContainsKey(guid)) {
+        // result already available
+        if(results.ContainsKey(guid)) {
+          // if the wait-handle for this result is still alive then close and remove it
+          if(waitHandles.ContainsKey(guid)) {
+            ManualResetEvent waitHandle = waitHandles[guid];
+            waitHandle.Close();
+            waitHandles.Remove(guid);
+          }
+          return results[guid];
+        } else {
+          // result not yet available, if there is also no wait-handle for that result then we will never have a result and can return null
+          if(!waitHandles.ContainsKey(guid)) return null;
+
+          // otherwise we have a wait-handle and can wait for the result
           ManualResetEvent waitHandle = waitHandles[guid];
+          // wait
           if(waitHandle.WaitOne(timeout, true)) {
+            // ok got the result in within the wait time => close and remove the wait-hande and return the result
             waitHandle.Close();
             waitHandles.Remove(guid);
             byte[] result = results[guid];
-            results.Remove(guid);
             return result;
           } else {
+            // no result yet return without result
             return null;
           }
-        } else {
-          return null;
         }
       }
@@ -133,11 +158,6 @@
 
     internal void AbortEngine(Guid guid) {
-      string clientUrl = "";
       lock(bigLock) {
-        if(runningClients.ContainsKey(guid)) {
-          clientUrl = runningClients[guid];
-          IClient client = clientChannelFactory.CreateChannel(new EndpointAddress(clientUrl));
-          client.Abort(guid);
-        } else if(waitingEngines.ContainsKey(guid)) {
+        if(waitingEngines.ContainsKey(guid)) {
           byte[] engine = waitingEngines[guid];
           waitingEngines.Remove(guid);
@@ -148,4 +168,13 @@
       }
     }
+
+    internal JobState JobState(Guid guid) {
+      lock(bigLock) {
+        if(waitingEngines.ContainsKey(guid)) return HeuristicLab.Grid.JobState.Waiting;
+        else if(waitHandles.ContainsKey(guid)) return HeuristicLab.Grid.JobState.Busy;
+        else if(results.ContainsKey(guid)) return HeuristicLab.Grid.JobState.Finished;
+        else return HeuristicLab.Grid.JobState.Unkown;
+      }
+    }
   }
 }
Index: /trunk/sources/HeuristicLab.Grid/GridServer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Grid/GridServer.cs	(revision 218)
+++ /trunk/sources/HeuristicLab.Grid/GridServer.cs	(revision 219)
@@ -35,4 +35,8 @@
     }
 
+    public JobState JobState(Guid guid) {
+      return engineStore.JobState(guid);
+    }
+
     public Guid BeginExecuteEngine(byte[] engine) {
       Guid guid = Guid.NewGuid();
Index: /trunk/sources/HeuristicLab.Grid/IEngineStore.cs
===================================================================
--- /trunk/sources/HeuristicLab.Grid/IEngineStore.cs	(revision 218)
+++ /trunk/sources/HeuristicLab.Grid/IEngineStore.cs	(revision 219)
@@ -30,5 +30,5 @@
   interface IEngineStore {
     [OperationContract]
-    bool TryTakeEngine(string clientUrl, out Guid guid, out byte[] engine);
+    bool TryTakeEngine(out Guid guid, out byte[] engine);
 
     [OperationContract]
Index: /trunk/sources/HeuristicLab.Grid/IGridServer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Grid/IGridServer.cs	(revision 218)
+++ /trunk/sources/HeuristicLab.Grid/IGridServer.cs	(revision 219)
@@ -26,6 +26,16 @@
 
 namespace HeuristicLab.Grid {
+  public enum JobState {
+    Unkown,
+    Waiting,
+    Busy,
+    Finished
+  }
+
+
   [ServiceContract(Namespace = "http://HeuristicLab.Grid")]
   public interface IGridServer {
+    [OperationContract]
+    JobState JobState(Guid guid);
     [OperationContract]
     Guid BeginExecuteEngine(byte[] engine);
Index: /trunk/sources/HeuristicLab.Grid/ProcessingEngine.cs
===================================================================
--- /trunk/sources/HeuristicLab.Grid/ProcessingEngine.cs	(revision 218)
+++ /trunk/sources/HeuristicLab.Grid/ProcessingEngine.cs	(revision 219)
@@ -68,9 +68,7 @@
           myExecutionStack.Push(atomicOperation);
           Abort();
-          ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex); });
         }
         if(next != null)
           myExecutionStack.Push(next);
-        OnOperationExecuted(atomicOperation);
         if(atomicOperation.Operator.Breakpoint) Abort();
       } else if(operation is CompositeOperation) {
