Changeset 2258 for trunk/sources/HeuristicLab.CEDMA.Server/3.3/GridExecuter.cs

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

File:

• trunk/sources/HeuristicLab.CEDMA.Server/3.3/GridExecuter.cs (modified) (5 diffs)

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)
     }