Index: /branches/HeuristicLab.DebugEngine/DebugEngine.cs
===================================================================
--- /branches/HeuristicLab.DebugEngine/DebugEngine.cs	(revision 4995)
+++ /branches/HeuristicLab.DebugEngine/DebugEngine.cs	(revision 4996)
@@ -49,5 +49,4 @@
       ExecutionStack = cloner.Clone(original.ExecutionStack);
       OperatorTrace = cloner.Clone(original.OperatorTrace);
-      operatorParents = original.operatorParents.ToDictionary(kvp => cloner.Clone(kvp.Key), kvp => cloner.Clone(kvp.Value));
       pausePending = original.pausePending;
       stopPending = original.stopPending;
@@ -61,5 +60,4 @@
       ExecutionStack = new ExecutionStack();
       OperatorTrace = new OperatorTrace();
-      operatorParents = new Dictionary<IAtomicOperation, IAtomicOperation>();
       pausePending = stopPending = false;
       InitializeTimer();
@@ -116,8 +114,4 @@
     }
 
-
-    [Storable]
-    private Dictionary<IAtomicOperation, IAtomicOperation> operatorParents;
-
     public virtual bool CanContinue {
       get { return CurrentOperation != null || ExecutionStack.Count > 0; }
@@ -147,6 +141,5 @@
       ExecutionStack.Clear();
       CurrentOperation = null;
-      OperatorTrace.Clear();
-      operatorParents.Clear();
+      OperatorTrace.Reset();
       OnPrepared();
     }
@@ -157,6 +150,5 @@
         ExecutionStack.Add(initialOperation);
       CurrentOperation = null;
-      OperatorTrace.Clear();
-      operatorParents.Clear();
+      OperatorTrace.Reset();
       OnPrepared();
     }
@@ -264,5 +256,5 @@
 
         if (atomicOperation != null) {
-          Log.LogMessage(string.Format("Performing atomic operation {0}", Name(atomicOperation)));
+          Log.LogMessage(string.Format("Performing atomic operation {0}", Utils.Name(atomicOperation)));
           PerformAtomicOperation(atomicOperation);
         } else if (operations != null) {
@@ -277,22 +269,7 @@
           Log.LogMessage("Nothing to do");
         }
-        GenerateOperationTrace();
+        OperatorTrace.Generate(CurrentAtomicOperation);
       } catch (Exception x) {
         OnExceptionOccurred(x);
-      }
-    }
-
-    private void GenerateOperationTrace() {
-      var operation = CurrentOperation as IAtomicOperation;
-      if (operation != null) {
-        List<IOperator> trace = new List<IOperator>();
-        while (operation != null) {
-          trace.Add(operation.Operator);
-          IAtomicOperation parent = null;
-          operatorParents.TryGetValue(operation, out parent);
-          operation = parent;
-        }
-        trace.Reverse();
-        OperatorTrace.ReplaceAll(trace);
       }
     }
@@ -304,5 +281,5 @@
           IOperation successor = operation.Operator.Execute((IExecutionContext)operation);
           if (successor != null) {
-            AssignParents(operation, successor);
+            OperatorTrace.RegisterParenthood(operation, successor);
             ExecutionStack.Add(successor);
           }
@@ -316,18 +293,4 @@
     }
 
-    private void AssignParents(IAtomicOperation parent, IOperation successor) {
-      OperationCollection operations = successor as OperationCollection;
-      if (operations != null)
-        foreach (var op in operations)
-          AssignParents(parent, op);
-      IAtomicOperation atomicOperation = successor as IAtomicOperation;
-      if (atomicOperation != null && atomicOperation.Operator != null && !operatorParents.ContainsKey(atomicOperation))
-        operatorParents[atomicOperation] = parent;
-    }
-
-    protected virtual string Name(IAtomicOperation operation) {
-      return string.IsNullOrEmpty(operation.Operator.Name) ? operation.Operator.ItemName : operation.Operator.Name;
-    }
-
     #endregion
   }
Index: /branches/HeuristicLab.DebugEngine/OperationContent.cs
===================================================================
--- /branches/HeuristicLab.DebugEngine/OperationContent.cs	(revision 4995)
+++ /branches/HeuristicLab.DebugEngine/OperationContent.cs	(revision 4996)
@@ -21,7 +21,5 @@
       ExecutionContext = operation as ExecutionContext;
       if (AtomicOperation != null) {
-        Name = string.IsNullOrEmpty(AtomicOperation.Operator.Name) ?
-          AtomicOperation.Operator.ItemName :
-          AtomicOperation.Operator.Name;
+        Name = Utils.Name(AtomicOperation);
       } else if (Collection != null) {
         Name = string.Format("{0} Operations", Collection.Count);
Index: /branches/HeuristicLab.DebugEngine/OperatorTrace.cs
===================================================================
--- /branches/HeuristicLab.DebugEngine/OperatorTrace.cs	(revision 4995)
+++ /branches/HeuristicLab.DebugEngine/OperatorTrace.cs	(revision 4996)
@@ -11,26 +11,44 @@
   public class OperatorTrace : ObservableList<IOperator>, IContent, IDeepCloneable {
 
-    public OperatorTrace()
-      : base() {
+    #region fields
+
+    [Storable]
+    protected Dictionary<IAtomicOperation, IAtomicOperation> parents;
+    #endregion
+
+    #region Constructors & Cloning
+
+    public OperatorTrace() {
+        parents = new Dictionary<IAtomicOperation, IAtomicOperation>();
     }
-    public OperatorTrace(int capacity)
-      : base(capacity) {
+
+    public OperatorTrace(int capacity) : base(capacity) {
+        parents = new Dictionary<IAtomicOperation, IAtomicOperation>();
     }
-    public OperatorTrace(IEnumerable<IOperator> collection)
-      : base(collection) {
+
+    public OperatorTrace(IEnumerable<IOperator> collection): base(collection) {
+        parents = new Dictionary<IAtomicOperation, IAtomicOperation>();
     }
 
     [StorableConstructor]
     protected OperatorTrace(bool deserializing) : base(deserializing) { }
+
     protected OperatorTrace(OperatorTrace original, Cloner cloner) {
       cloner.RegisterClonedObject(original, this);
       AddRange(original.Select(op => cloner.Clone(op)));
+      parents = original.parents.ToDictionary(kvp => cloner.Clone(kvp.Key), kvp => cloner.Clone(kvp.Value));
     }
+
     public object Clone() {
       return Clone(new Cloner());
     }
+
     public virtual IDeepCloneable Clone(Cloner cloner) {
       return new OperatorTrace(this, cloner);
     }
+    #endregion
+
+    #region Additional List Modifiers
+
     public virtual void ReplaceAll(IEnumerable<IOperator> operators) {
       var oldList = list;
@@ -44,4 +62,37 @@
     }
 
+    #endregion
+
+    #region Parent Tracing
+
+    public virtual void RegisterParenthood(IAtomicOperation parent, IOperation children) {
+      OperationCollection operations = children as OperationCollection;
+      if (operations != null)
+        foreach (var op in operations)
+          RegisterParenthood(parent, op);
+      IAtomicOperation atomicOperation = children as IAtomicOperation;
+      if (atomicOperation != null && atomicOperation.Operator != null && !parents.ContainsKey(atomicOperation))
+        parents[atomicOperation] = parent;
+    }
+
+    public virtual void Reset() {
+      Clear();
+      parents.Clear();
+    }
+
+    public virtual void Generate(IAtomicOperation operation) {
+      if (operation == null)
+        return;
+      Stack<IOperator> trace = new Stack<IOperator>();
+      while (operation != null) {
+        trace.Push(operation.Operator);
+        IAtomicOperation parent = null;
+        parents.TryGetValue(operation, out parent);
+        operation = parent;
+      }
+      ReplaceAll(trace);
+    }
+
+    #endregion
   }
 }
Index: /branches/HeuristicLab.DebugEngine/Utils.cs
===================================================================
--- /branches/HeuristicLab.DebugEngine/Utils.cs	(revision 4995)
+++ /branches/HeuristicLab.DebugEngine/Utils.cs	(revision 4996)
@@ -3,7 +3,13 @@
 using System.Text.RegularExpressions;
 using HeuristicLab.Persistence.Auxiliary;
+using HeuristicLab.Core;
 
 namespace HeuristicLab.DebugEngine {
   public static class Utils {
+
+    public static string Name(IAtomicOperation operation) {
+      return string.IsNullOrEmpty(operation.Operator.Name) ? operation.Operator.ItemName : operation.Operator.Name;
+    }
+
     public static string TypeName(object obj) {
       if (obj == null)
@@ -11,4 +17,5 @@
       return TypeNameParser.Parse(obj.GetType().ToString()).GetTypeNameInCode(true);
     }
+
     public static string Wrap(string text, int columns) {
       StringBuilder sb = new StringBuilder();
