src/Pure/Tools/build_schedule.scala

     }
 
     def finished: Boolean = build_state.pending.isEmpty && build_state.running.isEmpty
   }
 
-  abstract class Scheduler {
+  abstract class Scheduler(timing_data: Timing_Data) {
     def ready_jobs(state: Build_Process.State): Build_Process.State.Pending =
       state.pending.filter(entry => entry.is_ready && !state.is_running(entry.name))
 
-    def next(timing: Timing_Data, state: Build_Process.State): List[Config]
-
-    def build_duration(timing_data: Timing_Data, build_state: Build_Process.State): Time = {
+    def next(state: Build_Process.State): List[Config]
+
+    def build_duration(build_state: Build_Process.State): Time = {
       @tailrec
       def simulate(state: State): State =
         if (state.finished) state
         else {
           val state1 =
-            next(timing_data, state.build_state).foldLeft(state)(_.start(_)).step(timing_data)
+            next(state.build_state).foldLeft(state)(_.start(_)).step(timing_data)
           simulate(state1)
         }
 
       val start = Time.now()
       simulate(State(build_state, start)).current_time - start

   }
 
 
   /* heuristics */
 
-  class Timing_Heuristic(threshold: Time) extends Scheduler {
-    def next(timing_data: Timing_Data, state: Build_Process.State): List[Config] = {
+  class Timing_Heuristic(threshold: Time, timing_data: Timing_Data) extends Scheduler(timing_data) {
+    def next(state: Build_Process.State): List[Config] = {
       val host_infos = timing_data.host_infos
       val resources = host_infos.available(state)
 
       def best_threads(task: Build_Process.Task): Int =
         timing_data.best_threads(task.name).getOrElse(

         configs1 ::: configs2
       }
     }
   }
 
-  class Meta_Heuristic(schedulers: List[Scheduler]) extends Scheduler {
+  class Meta_Heuristic(schedulers: List[Scheduler], timing_data: Timing_Data)
+    extends Scheduler(timing_data) {
     require(schedulers.nonEmpty)
 
-    def next(timing_data: Timing_Data, state: Build_Process.State): List[Config] = {
-      val (best, _) = schedulers.map(h => h -> h.build_duration(timing_data, state)).minBy(_._2.ms)
-      best.next(timing_data, state)
+    def next(state: Build_Process.State): List[Config] = {
+      val (best, _) = schedulers.map(h => h -> h.build_duration(state)).minBy(_._2.ms)
+      best.next(state)
     }
   }
 
 
   /* process for scheduled build */
 
-  class Scheduled_Build_Process(
-    scheduler: Scheduler,
+  abstract class Scheduled_Build_Process(
     build_context: Build.Context,
     build_progress: Progress,
     server: SSH.Server,
   ) extends Build_Process(build_context, build_progress, server) {
     protected val start_date = Date.now()
 
+    def init_scheduler(timing_data: Timing_Data): Scheduler
 
     /* global resources with common close() operation */
 
     private final lazy val _log_store: Build_Log.Store = Build_Log.store(build_options)
     private final lazy val _log_database: SQL.Database =

           build_info = _log_store.read_build_info(_log_database, log_name)
         } yield (meta_info, build_info)
 
       Timing_Data.make(host_infos, build_history)
     }
+    private val scheduler = init_scheduler(timing_data)
 
     def write_build_log(results: Build.Results, state: Build_Process.State.Results): Unit = {
       val sessions =
         for {
           (session_name, result) <- state.toList

     private var cache = Cache(Build_Process.State(), Nil, Date.now())
 
     override def next_node_info(state: Build_Process.State, session_name: String): Node_Info = {
       val configs =
         if (cache.is_current(state)) cache.configs
-        else scheduler.next(timing_data, state)
+        else scheduler.next(state)
       configs.find(_.job_name == session_name).get.node_info
     }
 
     override def next_jobs(state: Build_Process.State): List[String] =
       if (cache.is_current(state)) cache.configs.map(_.job_name)
       else {
         val start = Time.now()
-        val next = scheduler.next(timing_data, state)
-        val estimate = Date(Time.now() + scheduler.build_duration(timing_data, state))
+        val next = scheduler.next(state)
+        val estimate = Date(Time.now() + scheduler.build_duration(state))
         val elapsed = Time.now() - start
 
         val timing_msg = if (elapsed.is_relevant) " (in " + elapsed.message + ")" else ""
         progress.echo_if(build_context.master && !cache.is_current_estimate(estimate),
           "Estimated completion: " + estimate + timing_msg)

   class Engine extends Build.Engine(engine_name) {
     override def open_build_process(
       context: Build.Context,
       progress: Progress,
       server: SSH.Server
-    ): Build_Process = {
-      val heuristics = List(5, 10, 20).map(minutes => Timing_Heuristic(Time.minutes(minutes)))
-      val scheduler = new Meta_Heuristic(heuristics)
-      new Scheduled_Build_Process(scheduler, context, progress, server)
-    }
+    ): Build_Process =
+      new Scheduled_Build_Process(context, progress, server) {
+        def init_scheduler(timing_data: Timing_Data): Scheduler = {
+          val heuristics =
+            List(5, 10, 20).map(minutes => Timing_Heuristic(Time.minutes(minutes), timing_data))
+          new Meta_Heuristic(heuristics, timing_data)
+        }
+      }
   }
 }