Changeset 2258 for trunk

Timestamp:

08/07/09 16:50:07 (15 years ago)

Author:

gkronber

Message:

• Reimplemented method to read a list of already executed algorithms and configurations from the results DB
• Fixed a bug in the GridExecuter
• Added a button in the dispatcher view to speed up configuration of input variables

#712

Location:

trunk/sources/HeuristicLab.CEDMA.Server/3.3

Files:

• DispatcherBase.cs (modified) (1 diff)
• DispatcherView.Designer.cs (modified) (5 diffs)
• DispatcherView.cs (modified) (1 diff)
• GridExecuter.cs (modified) (5 diffs)
• SimpleDispatcher.cs (modified) (3 diffs)

trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherBase.cs

@@ -38 +38 @@
   public abstract class DispatcherBase : IDispatcher {
     private IModelingDatabase database;
+    public IModelingDatabase Database {
+      get {
+        return database;
+      }
+    }
     private List<int> allowedTargetVariables;
     private Dictionary<int, List<int>> activeInputVariables;
     private Problem problem;
+    public Problem Problem {
+      get {
+        return problem;
+      }
+    }
     internal event EventHandler Changed;
     private object locker = new object();

trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherView.Designer.cs

@@ -29 +29 @@
       this.inputVariablesLabel = new System.Windows.Forms.Label();
       this.splitContainer = new System.Windows.Forms.SplitContainer();
+      this.setAllButton = new System.Windows.Forms.Button();
       this.splitContainer.Panel1.SuspendLayout();
       this.splitContainer.Panel2.SuspendLayout();
@@ -57 +58 @@
       this.inputVariableList.Location = new System.Drawing.Point(2, 16);
       this.inputVariableList.Name = "inputVariableList";
-      this.inputVariableList.Size = new System.Drawing.Size(221, 454);
+      this.inputVariableList.Size = new System.Drawing.Size(221, 439);
       this.inputVariableList.TabIndex = 1;
       this.inputVariableList.ItemCheck += new System.Windows.Forms.ItemCheckEventHandler(this.inputVariableList_ItemCheck);
@@ -92 +93 @@
       // splitContainer.Panel2
       // 
+      this.splitContainer.Panel2.Controls.Add(this.setAllButton);
       this.splitContainer.Panel2.Controls.Add(this.inputVariablesLabel);
       this.splitContainer.Panel2.Controls.Add(this.inputVariableList);
@@ -98 +100 @@
       this.splitContainer.SplitterWidth = 1;
       this.splitContainer.TabIndex = 4;
+      // 
+      // setAllButton
+      // 
+      this.setAllButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.setAllButton.Location = new System.Drawing.Point(3, 456);
+      this.setAllButton.Name = "setAllButton";
+      this.setAllButton.Size = new System.Drawing.Size(91, 23);
+      this.setAllButton.TabIndex = 4;
+      this.setAllButton.Text = "Use as default";
+      this.setAllButton.UseVisualStyleBackColor = true;
+      this.setAllButton.Click += new System.EventHandler(this.setAllButton_Click);
       // 
       // DispatcherView
@@ -122 +135 @@
     private System.Windows.Forms.Label inputVariablesLabel;
     private System.Windows.Forms.SplitContainer splitContainer;
+    private System.Windows.Forms.Button setAllButton;
   }
 }

trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherView.cs

@@ -71 +71 @@
       inputVariableList.Enabled = true;
     }
+
+    private void setAllButton_Click(object sender, EventArgs e) {      
+      foreach (string targetVar in dispatcher.TargetVariables) {
+        for (int i = 0; i < inputVariableList.Items.Count; i++) {
+          if (inputVariableList.GetItemChecked(i)) {
+            dispatcher.EnableInputVariable(targetVar, (string)inputVariableList.Items[i]);
+          } else {
+            dispatcher.DisableInputVariable(targetVar, (string)inputVariableList.Items[i]);
+          }
+        }
+      }
+    }
   }
 }

trunk/sources/HeuristicLab.CEDMA.Server/3.3/GridExecuter.cs

@@ -44 +44 @@
 
     private TimeSpan StartJobInterval {
-      get { return TimeSpan.FromMilliseconds(500); }
+      get { return TimeSpan.FromMilliseconds(3000); }
     }
 
@@ -51 +51 @@
     }
 
-    private TimeSpan WaitForNewJobsInterval {
-      get { return TimeSpan.FromSeconds(3); }
-    }
-
-    public GridExecuter(IDispatcher dispatcher,  IGridServer server, IModelingDatabase databaseService)
+    public GridExecuter(IDispatcher dispatcher, IGridServer server, IModelingDatabase databaseService)
       : base(dispatcher, databaseService) {
       this.jobManager = new JobManager(server);
@@ -64 +60 @@
     protected override void StartJobs() {
       Dictionary<WaitHandle, AsyncGridResult> asyncResults = new Dictionary<WaitHandle, AsyncGridResult>();
+      // inifinite loop:
+      // 1. try to dispatch one algo
+      // 2. when at least one run is dispatched try to get the result
+      // 3. sleep
       while (true) {
         try {
-          // start new jobs as long as there are less than MaxActiveJobs 
-          while (asyncResults.Count < MaxActiveJobs) {
-            Thread.Sleep(StartJobInterval);
+          // if allowed then try to dispatch another run
+          if (asyncResults.Count < MaxActiveJobs) {
             // get an execution from the dispatcher and execute in grid via job-manager
             HeuristicLab.Modeling.IAlgorithm algorithm = Dispatcher.GetNextJob();
@@ -85 +84 @@
             }
           }
+          // when there are active runs
           if (asyncResults.Count > 0) {
             WaitHandle[] whArr = asyncResults.Keys.ToArray();
             int readyHandleIndex = WaitAny(whArr, WaitForFinishedJobsTimeout);
+            // if the wait didn't timeout, a new result is ready
             if (readyHandleIndex != WaitHandle.WaitTimeout) {
+              // request the finished run and clean up
               WaitHandle readyHandle = whArr[readyHandleIndex];
+              AsyncGridResult finishedResult = asyncResults[readyHandle];
+              asyncResults.Remove(readyHandle);
               HeuristicLab.Modeling.IAlgorithm finishedAlgorithm = null;
-              AsyncGridResult finishedResult = null;
               lock (activeAlgorithms) {
-                finishedResult = asyncResults[readyHandle];
                 finishedAlgorithm = activeAlgorithms[finishedResult];
                 activeAlgorithms.Remove(finishedResult);
-                asyncResults.Remove(readyHandle);
               }
               OnChanged();
@@ -105 +106 @@
               }
               catch (Exception badEx) {
-                HeuristicLab.Tracing.Logger.Error("CEDMA Executer: Exception in job execution thread. " + badEx.Message+Environment.NewLine+badEx.StackTrace);
+                HeuristicLab.Tracing.Logger.Error("CEDMA Executer: Exception in job execution thread. " + badEx.Message + Environment.NewLine + badEx.StackTrace);
               }
             }
-          } else {
-            Thread.Sleep(WaitForNewJobsInterval);
           }
+          // when there are no active runs then sleep until we try to start a new run (to prevent excessive looping)
+          Thread.Sleep(StartJobInterval);
         }
-
         catch (Exception ex) {
           HeuristicLab.Tracing.Logger.Warn("CEDMA Executer: Exception in job-management thread. " + ex.Message + Environment.NewLine + ex.StackTrace);
         }
-      }
+      } // end while(true)
     }
 

trunk/sources/HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs

@@ -60 +60 @@
         case LearningTask.Regression: {
             var regressionAlgos = algos.Where(a => (a as IClassificationAlgorithm) == null && (a as ITimeSeriesAlgorithm) == null);
-            selectedAlgorithm = ChooseDeterministic(targetVariable, inputVariables, regressionAlgos) ?? ChooseStochastic(regressionAlgos);
+            selectedAlgorithm = ChooseDeterministic(targetVariable, inputVariables, regressionAlgos); //  ?? ChooseStochastic(regressionAlgos);
             break;
           }
@@ -99 +99 @@
 
     private void PopulateFinishedRuns() {
-      //Dictionary<Entity, Entity> processedModels = new Dictionary<Entity, Entity>();
-      //var datasetBindings = store
-      //  .Query(
-      //  "?Dataset <" + Ontology.InstanceOf + "> <" + Ontology.TypeDataSet + "> .", 0, 1)
-      //  .Select(x => (Entity)x.Get("Dataset"));
-
-      //if (datasetBindings.Count() > 0) {
-      //  var datasetEntity = datasetBindings.ElementAt(0);
-
-      //  DataSet ds = new DataSet(store, datasetEntity);
-      //  var result = store
-      //    .Query(
-      //    "?Model <" + Ontology.TargetVariable + "> ?TargetVariable ." + Environment.NewLine +
-      //    "?Model <" + Ontology.Name + "> ?AlgoName .",
-      //    0, 1000)
-      //    .Select(x => new Resource[] { (Literal)x.Get("TargetVariable"), (Literal)x.Get("AlgoName"), (Entity)x.Get("Model") });
-
-      //  foreach (Resource[] row in result) {
-      //    Entity model = ((Entity)row[2]);
-      //    if (!processedModels.ContainsKey(model)) {
-      //      processedModels.Add(model, model);
-
-      //      string targetVariable = (string)((Literal)row[0]).Value;
-      //      string algoName = (string)((Literal)row[1]).Value;
-      //      int targetVariableIndex = ds.Problem.Dataset.GetVariableIndex(targetVariable);
-
-      //      var inputVariableLiterals = store
-      //        .Query(
-      //          "<" + model.Uri + "> <" + Ontology.HasInputVariable + "> ?InputVariable ." + Environment.NewLine +
-      //          "?InputVariable <" + Ontology.Name + "> ?Name .",
-      //          0, 1000)
-      //        .Select(x => (Literal)x.Get("Name"))
-      //        .Select(l => (string)l.Value)
-      //        .Distinct();
-
-      //      List<int> inputVariables = new List<int>();
-      //      foreach (string variableName in inputVariableLiterals) {
-      //        int variableIndex = ds.Problem.Dataset.GetVariableIndex(variableName);
-      //        inputVariables.Add(variableIndex);
-      //      }
-      //      if (!AlgorithmFinishedOrDispatched(targetVariableIndex, inputVariables.ToArray(), algoName)) {
-      //        AddDispatchedRun(targetVariableIndex, inputVariables.ToArray(), algoName);
-      //      }
-      //    }
-      //  }
-      //}
+      var dispatchedAlgos = from model in Database.GetAllModels()
+                            select new { 
+                              TargetVariable = model.TargetVariable.Name, 
+                              Algorithm = model.Algorithm.Name, 
+                              Inputvariables = Database.GetInputVariableResults(model).Select(x => x.Variable.Name).Distinct() };
+      foreach (var algo in dispatchedAlgos) {
+        AddDispatchedRun(algo.TargetVariable, algo.Inputvariables, algo.Algorithm);
+      }
     }
 
@@ -180 +142 @@
     }
 
+    private void AddDispatchedRun(string targetVariable, IEnumerable<string> inputVariables, string algorithm) {
+      AddDispatchedRun(
+        Problem.Dataset.GetVariableIndex(targetVariable), 
+        inputVariables.Select(x => Problem.Dataset.GetVariableIndex(x)).ToArray(), 
+        algorithm);
+    }
+
     private void AddDispatchedRun(int targetVariable, int[] inputVariables, string algoName) {
       if (!finishedAndDispatchedRuns.ContainsKey(targetVariable)) {