Changeset 1789 for trunk/sources/HeuristicLab.FixedOperators/3.2/FixedOperatorBase.cs

Timestamp:

05/13/09 16:39:11 (15 years ago)

Author:

dtraxing

Message:

improved support for algorithm abort. (ticket #580)

File:

• trunk/sources/HeuristicLab.FixedOperators/3.2/FixedOperatorBase.cs (moved) (moved from trunk/sources/HeuristicLab.FixedOperators/3.2/FixedBase.cs) (1 diff)

trunk/sources/HeuristicLab.FixedOperators/3.2/FixedOperatorBase.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using HeuristicLab.Core;
 using HeuristicLab.Operators;
+using HeuristicLab.Data;
+using System.Threading;
+using System.Diagnostics;
 
 namespace HeuristicLab.FixedOperators {
-  class FixedBase : CombinedOperator {
+  class FixedOperatorBase : CombinedOperator {
 
-    protected virtual void Execute(IOperator op, IScope scope){
-      IOperation operation;
-      IOperator currentOperator;
-      Stack<IOperation> executionStack = new Stack<IOperation>();
-      executionStack.Push(op.Execute(scope));
+    private class TasksList {
+      public IOperator op;
+      public IScope scope;
+      public ManualResetEvent resetEvent;
+    }
+    /// <summary>
+    /// Execution pointer shows which command actually is executed
+    /// </summary>
+    protected int executionPointer;
 
-      while (executionStack.Count > 0) {
-        operation = executionStack.Pop();
-        if (operation is AtomicOperation) {
-          AtomicOperation atomicOperation = (AtomicOperation)operation;
-          IOperation next = null;
+    /// <summary>
+    /// Execution pointer if execution was aborted previously
+    /// </summary>
+    protected IntData persistedExecutionPointer;
+
+    /// <summary>
+    /// If true, mini engine is executed in its own thread.
+    /// </summary>
+    protected bool threaded;
+
+    protected Thread engineThread;
+
+    /// <summary>
+    /// Current operator in execution.
+    /// </summary>
+    protected IOperator currentOperator;
+
+    public FixedOperatorBase() : base() {
+      //AddVariableInfo(new VariableInfo("ExecutionPointer", "Execution pointer for algorithm abortion", typeof(IntData), VariableKind.New));   
+    } // FixedOperatorBase
+
+    private bool IsExecuted() {
+      return persistedExecutionPointer.Data > executionPointer;
+    } // AlreadyExecuted
+
+    protected virtual void Execute(IOperator op, IScope scope, bool runInThread) {
+      if (!IsExecuted()) {
+        if (runInThread) {
           try {
-            currentOperator = atomicOperation.Operator;
-            next = atomicOperation.Operator.Execute(atomicOperation.Scope);
+            // causes fatal computing overhead 5:30 minutes for sga
+            //engineThread = new Thread(new ThreadStart(ExecuteOperation));
+            //engineThread.Start();
+            //engineThread.Join();
+
+            // causes computing overhead, 11 sec for sga
+            Stopwatch sw = new Stopwatch();
+            sw.Start();
+            TasksList tl = new TasksList() { op = op, scope = scope, resetEvent = new ManualResetEvent(false) };
+            Console.WriteLine(sw.ElapsedTicks);     
+            ThreadPool.QueueUserWorkItem(new WaitCallback(ExecuteOperationThreaded), (object)tl);
+            Console.WriteLine(sw.ElapsedTicks);
+            WaitHandle.WaitAll(new WaitHandle[] { tl.resetEvent });
+            Console.WriteLine(sw.ElapsedTicks); 
           }
-          catch (Exception) {
-            //Abort();
-            //ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex); });
-            throw new InvalidOperationException("Invalid Operation occured in FixedBase.Execute");
+          catch (ThreadAbortException) {
+            return;
           }
-          if (next != null)
-            executionStack.Push(next);
-        } else if (operation is CompositeOperation) {
-          CompositeOperation compositeOperation = (CompositeOperation)operation;
-          for (int i = compositeOperation.Operations.Count - 1; i >= 0; i--)
-            executionStack.Push(compositeOperation.Operations[i]);
-        } // else if
-      } // while
+        } else {
+          ExecuteOperation(op, scope);
+        }
+        persistedExecutionPointer.Data++;
+      } // if not executed
+      executionPointer++;
+      Console.WriteLine(executionPointer);
+
+      if (Canceled)
+        throw new CancelException();
     } // Execute
 
+    private void ExecuteOperationThreaded(object o) {
+      TasksList tl = (TasksList)o;
+      ExecuteOperation(tl.op, tl.scope);
+      tl.resetEvent.Set();
+    } // ExecuteOperationThreaded 
+
+    protected void ExecuteOperation(IOperator op, IScope scope) {
+      IOperation operation;
+      currentOperator = op;
+      operation = op.Execute(scope);
+      if (operation != null) {
+        //IOperator currentOperator;
+        Stack<IOperation> executionStack = new Stack<IOperation>();
+        executionStack.Push(op.Execute(scope));
+
+        while (executionStack.Count > 0) {
+          operation = executionStack.Pop();
+          if (operation is AtomicOperation) {
+            AtomicOperation atomicOperation = (AtomicOperation)operation;
+            IOperation next = null;
+            try {
+              currentOperator = atomicOperation.Operator;
+              next = currentOperator.Execute(atomicOperation.Scope);
+            }
+            catch (Exception) {
+              throw new InvalidOperationException("Invalid Operation occured in FixedBase.Execute");
+            }
+            if (next != null)
+              executionStack.Push(next);
+          } else if (operation is CompositeOperation) {
+            CompositeOperation compositeOperation = (CompositeOperation)operation;
+            for (int i = compositeOperation.Operations.Count - 1; i >= 0; i--)
+              executionStack.Push(compositeOperation.Operations[i]);
+          } // else if
+        } // while
+      } // if (operation != null)
+    } // ExecuteOperation
+
+    public override IOperation Apply(IScope scope) {
+      try {
+        persistedExecutionPointer = scope.GetVariableValue<IntData>("ExecutionPointer", false);
+      }
+      catch (Exception) {
+        persistedExecutionPointer = new IntData(0);
+        scope.AddVariable(new Variable("ExecutionPointer", persistedExecutionPointer));
+      }
+      
+      executionPointer = 0;
+      return null;
+    } // Apply
+
+    public override void Abort() {
+      base.Abort();
+      currentOperator.Abort();
+      //engineThread.Abort();
+    }
+
+
+
   } // class FixedBase
+
+  class CancelException : Exception { 
+  
+  } // class CancelException
 } // namespace HeuristicLab.FixedOperators