Changeset 10479 for branches/SpectralKernelForGaussianProcesses/HeuristicLab.Operators/3.3

Timestamp:

02/20/14 14:29:01 (10 years ago)

Author:

gkronber

Message:

#2124 merged all changes from trunk to prepare for trunk-reintegration

Location:

branches/SpectralKernelForGaussianProcesses

Files:

• . (modified) (1 prop)
• HeuristicLab.Operators/3.3/InstrumentedOperator.cs (modified) (6 diffs)
• HeuristicLab.Operators/3.3/MultiOperator.cs (modified) (1 diff)
• HeuristicLab.Operators/3.3/StochasticMultiBranch.cs (modified) (2 diffs)
• HeuristicLab.Operators/3.3/SubScopesProcessor.cs (modified) (1 diff)

branches/SpectralKernelForGaussianProcesses/HeuristicLab.Operators/3.3/InstrumentedOperator.cs

@@ -20 +20 @@
 #endregion
 
+using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28 +30 @@
   [Item("InstrumentedOperator", "A operator that can execute pre- and post actions.")]
   [StorableClass]
-  public abstract class InstrumentedOperator : SingleSuccessorOperator {
+  public abstract class InstrumentedOperator : SingleSuccessorOperator, IInstrumentedOperator {
     private const string BeforeExecutionOperatorsParameterName = "BeforeExecutionOperators";
     private const string AfterExecutionOperatorsParameterName = "AfterExecutionOperators";
 
-    private IFixedValueParameter<ItemList<SingleSuccessorOperator>> BeforeExecutionOperatorsParameter {
-      get { return (IFixedValueParameter<ItemList<SingleSuccessorOperator>>)Parameters[BeforeExecutionOperatorsParameterName]; }
+    private IFixedValueParameter<OperatorList> BeforeExecutionOperatorsParameter {
+      get { return (IFixedValueParameter<OperatorList>)Parameters[BeforeExecutionOperatorsParameterName]; }
     }
-    private IFixedValueParameter<ItemList<SingleSuccessorOperator>> AfterExecutionOperatorsParameter {
-      get { return (IFixedValueParameter<ItemList<SingleSuccessorOperator>>)Parameters[AfterExecutionOperatorsParameterName]; }
+    private IFixedValueParameter<OperatorList> AfterExecutionOperatorsParameter {
+      get { return (IFixedValueParameter<OperatorList>)Parameters[AfterExecutionOperatorsParameterName]; }
     }
 
-    public ItemList<SingleSuccessorOperator> BeforeExecutionOperators {
+
+    IEnumerable<IOperator> IInstrumentedOperator.BeforeExecutionOperators { get { return BeforeExecutionOperators; } }
+    public OperatorList BeforeExecutionOperators {
       get { return BeforeExecutionOperatorsParameter.Value; }
     }
-    public ItemList<SingleSuccessorOperator> AfterExecutionOperators {
+    IEnumerable<IOperator> IInstrumentedOperator.AfterExecutionOperators { get { return AfterExecutionOperators; } }
+    public OperatorList AfterExecutionOperators {
       get { return AfterExecutionOperatorsParameter.Value; }
     }
@@ -53 +58 @@
     protected InstrumentedOperator()
       : base() {
-      Parameters.Add(new FixedValueParameter<ItemList<SingleSuccessorOperator>>(BeforeExecutionOperatorsParameterName, "Actions that are executed before the execution of the operator", new ItemList<SingleSuccessorOperator>()));
-      Parameters.Add(new FixedValueParameter<ItemList<SingleSuccessorOperator>>(AfterExecutionOperatorsParameterName, "Actions that are executed after the execution of the operator", new ItemList<SingleSuccessorOperator>()));
+      Parameters.Add(new FixedValueParameter<OperatorList>(BeforeExecutionOperatorsParameterName, "Actions that are executed before the execution of the operator", new OperatorList()));
+      Parameters.Add(new FixedValueParameter<OperatorList>(AfterExecutionOperatorsParameterName, "Actions that are executed after the execution of the operator", new OperatorList()));
       BeforeExecutionOperatorsParameter.Hidden = true;
       AfterExecutionOperatorsParameter.Hidden = true;
@@ -64 +69 @@
       #region Backwards compatible code, remove with 3.4
       if (!Parameters.ContainsKey(BeforeExecutionOperatorsParameterName)) {
-        Parameters.Add(new FixedValueParameter<ItemList<SingleSuccessorOperator>>(BeforeExecutionOperatorsParameterName, "Actions that are executed before the execution of the operator", new ItemList<SingleSuccessorOperator>()));
+        Parameters.Add(new FixedValueParameter<OperatorList>(BeforeExecutionOperatorsParameterName, "Actions that are executed before the execution of the operator", new OperatorList()));
         BeforeExecutionOperatorsParameter.Hidden = true;
       }
       if (!Parameters.ContainsKey(AfterExecutionOperatorsParameterName)) {
-        Parameters.Add(new FixedValueParameter<ItemList<SingleSuccessorOperator>>(AfterExecutionOperatorsParameterName, "Actions that are executed after the execution of the operator", new ItemList<SingleSuccessorOperator>()));
+        Parameters.Add(new FixedValueParameter<OperatorList>(AfterExecutionOperatorsParameterName, "Actions that are executed after the execution of the operator", new OperatorList()));
         AfterExecutionOperatorsParameter.Hidden = true;
       }
@@ -75 +80 @@
 
     public sealed override IOperation Apply() {
-      var opCol = new OperationCollection();
+      //to speed up the execution call instrumented apply directly if no before operators exists
+      if (!BeforeExecutionOperators.Any())
+        return InstrumentedApply();
 
       //build before operations
+      var opCol = new OperationCollection();
       foreach (var beforeAction in BeforeExecutionOperators) {
-        IOperation beforeActionOperation = ExecutionContext.CreateOperation(beforeAction);
+        var beforeActionOperation = ExecutionContext.CreateChildOperation(beforeAction);
         opCol.Add(beforeActionOperation);
       }
@@ -88 +96 @@
 
     public virtual IOperation InstrumentedApply() {
+      if (!AfterExecutionOperators.Any()) {
+        if (Successor != null) return ExecutionContext.CreateOperation(Successor);
+        return null;
+      }
+
       var opCol = new OperationCollection();
       foreach (var afterAction in AfterExecutionOperators) {
-        IOperation afterActionOperation = ExecutionContext.CreateOperation(afterAction);
+        var afterActionOperation = ExecutionContext.CreateChildOperation(afterAction);
         opCol.Add(afterActionOperation);
       }
+
       if (Successor != null)
         opCol.Add(ExecutionContext.CreateOperation(Successor));

branches/SpectralKernelForGaussianProcesses/HeuristicLab.Operators/3.3/MultiOperator.cs

@@ -34 +34 @@
   [Item("MultiOperator", "A base class for operators which apply arbitrary many other operators of a specific type.")]
   [StorableClass]
-  public abstract class MultiOperator<T> : SingleSuccessorOperator, IMultiOperator<T> where T : class, IOperator {
+  public abstract class MultiOperator<T> : InstrumentedOperator, IMultiOperator<T> where T : class, IOperator {
     private List<IValueParameter<T>> operatorParameters;
     protected IEnumerable<IValueParameter<T>> OperatorParameters { get { return operatorParameters; } }

branches/SpectralKernelForGaussianProcesses/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs

@@ -132 +132 @@
     /// or all selected operators have zero probabitlity.</exception>
     /// <returns>A new operation with the operator that was selected followed by the current operator's successor.</returns>
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IRandom random = RandomParameter.ActualValue;
       DoubleArray probabilities = ProbabilitiesParameter.ActualValue;
@@ -156 +156 @@
         }
       }
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
       if (successor != null) {
         if (TraceSelectedOperatorParameter.Value.Value)

branches/SpectralKernelForGaussianProcesses/HeuristicLab.Operators/3.3/SubScopesProcessor.cs

@@ -67 +67 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       List<IScope> scopes = GetScopesOnLevel(ExecutionContext.Scope, Depth.Value).ToList();
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
       if (scopes.Count != Operators.Count)
         throw new ArgumentException("The number of operators doesn't match the number of sub-scopes at depth " + Depth.Value);