src/Pure/Build/build_schedule.scala

     }
 
     def is_finished: Boolean = build_state.pending.isEmpty && build_state.running.isEmpty
   }
 
-  trait Scheduler { def build_schedule(build_state: Build_Process.State): Schedule }
-
-  abstract class Heuristic(timing_data: Timing_Data, build_uuid: String)
-    extends Scheduler {
-    val host_infos = timing_data.host_infos
-    val ordered_hosts = host_infos.hosts.sorted(host_infos.host_speeds)
-
-    def next(state: Build_Process.State): List[Config]
-
-    def build_schedule(build_state: Build_Process.State): Schedule = {
+  trait Scheduler { def schedule(build_state: Build_Process.State): Schedule }
+
+  trait Priority_Rule { def select_next(state: Build_Process.State): List[Config] }
+
+  case class Generation_Scheme(
+    priority_rule: Priority_Rule,
+    timing_data: Timing_Data,
+    build_uuid: String
+  ) extends Scheduler {
+    def schedule(build_state: Build_Process.State): Schedule = {
       @tailrec
       def simulate(state: State): State =
         if (state.is_finished) state
         else {
-          val state1 = next(state.build_state).foldLeft(state)(_.start(_)).step(timing_data)
+          val state1 =
+            priority_rule
+              .select_next(state.build_state)
+              .foldLeft(state)(_.start(_))
+              .step(timing_data)
           simulate(state1)
         }
 
       val start = Date.now()
+      val name = "generation scheme (" + priority_rule + ")"
       val end_state =
-        simulate(State(build_state, start.time, Schedule(build_uuid, toString, start, Graph.empty)))
+        simulate(State(build_state, start.time, Schedule(build_uuid, name, start, Graph.empty)))
 
       end_state.finished
     }
   }
 
-  class Default_Heuristic(timing_data: Timing_Data, options: Options, build_uuid: String)
-    extends Heuristic(timing_data, build_uuid) {
-    override def toString: String = "default build heuristic"
+  case class Optimizer(schedulers: List[Scheduler]) extends Scheduler {
+    require(schedulers.nonEmpty)
+
+    def schedule(state: Build_Process.State): Schedule =
+      schedulers.map(_.schedule(state)).minBy(_.duration.ms)
+  }
+
+
+  /* priority rules */
+
+  class Default_Heuristic(host_infos: Host_Infos, options: Options) extends Priority_Rule {
+    override def toString: String = "default heuristic"
 
     def host_threads(host: Host): Int = {
       val m = (options ++ host.build.options).int("threads")
       if (m > 0) m else (host.num_cpus max 1) min 8
     }
 
     def next_jobs(resources: Resources, sorted_jobs: List[String], host: Host): List[Config] =
       sorted_jobs.zip(resources.unused_nodes(host, host_threads(host))).map(Config(_, _))
 
-    def next(state: Build_Process.State): List[Config] = {
+    def select_next(state: Build_Process.State): List[Config] = {
       val sorted_jobs = state.next_ready.sortBy(_.name)(state.sessions.ordering).map(_.name)
       val resources = host_infos.available(state)
 
       host_infos.hosts.foldLeft((sorted_jobs, List.empty[Config])) {
         case ((jobs, res), host) =>

           (jobs.filterNot(config_jobs.contains), configs ::: res)
       }._2
     }
   }
 
-  class Meta_Heuristic(heuristics: List[Heuristic]) extends Scheduler {
-    require(heuristics.nonEmpty)
-
-    def best_result(state: Build_Process.State): (Heuristic, Schedule) =
-      heuristics.map(heuristic =>
-        heuristic -> heuristic.build_schedule(state)).minBy(_._2.duration.ms)
-
-    def next(state: Build_Process.State): List[Config] = best_result(state)._1.next(state)
-
-    def build_schedule(state: Build_Process.State): Schedule = best_result(state)._2
-  }
-
-
-  /* heuristics */
-
-  abstract class Path_Heuristic(
-    timing_data: Timing_Data,
-    sessions_structure: Sessions.Structure,
-    max_threads_limit: Int,
-    build_uuid: String
-  ) extends Heuristic(timing_data, build_uuid) {
-    /* pre-computed properties for efficient heuristic */
-
-    val max_threads = host_infos.hosts.map(_.info.num_cpus).max min max_threads_limit
-
-    type Node = String
-    val build_graph = sessions_structure.build_graph
-
-    val minimals = build_graph.minimals
-    val maximals = build_graph.maximals
-
-    def all_preds(node: Node): Set[Node] = build_graph.all_preds(List(node)).toSet
-    val maximals_all_preds = maximals.map(node => node -> all_preds(node)).toMap
-
-    def best_time(node: Node): Time = {
-      val host = ordered_hosts.last
-      val threads = timing_data.best_threads(node, max_threads) min host.info.num_cpus
-      timing_data.estimate(node, host.name, threads)
-    }
-    val best_times = build_graph.keys.map(node => node -> best_time(node)).toMap
-
-    val succs_max_time_ms = build_graph.node_height(best_times(_).ms)
-    def max_time(node: Node): Time = Time.ms(succs_max_time_ms(node)) + best_times(node)
-    def max_time(task: Build_Process.Task): Time = max_time(task.name)
-
-    def path_times(minimals: List[Node]): Map[Node, Time] = {
-      def time_ms(node: Node): Long = best_times(node).ms
-      val path_times_ms = build_graph.reachable_length(time_ms, build_graph.imm_succs, minimals)
-      path_times_ms.view.mapValues(Time.ms).toMap
-    }
-
-    def path_max_times(minimals: List[Node]): Map[Node, Time] =
-      path_times(minimals).toList.map((node, time) => node -> (time + max_time(node))).toMap
-
-    def parallel_paths(running: List[(Node, Time)], pred: Node => Boolean = _ => true): Int = {
-      def start(node: Node): (Node, Time) = node -> best_times(node)
-
-      def pass_time(elapsed: Time)(node: Node, time: Time): (Node, Time) =
-        node -> (time - elapsed)
-
-      def parallel_paths(running: Map[Node, Time]): (Int, Map[Node, Time]) =
-        if (running.isEmpty) (0, running)
-        else {
-          def get_next(node: Node): List[Node] =
-            build_graph.imm_succs(node).filter(pred).filter(
-              build_graph.imm_preds(_).intersect(running.keySet) == Set(node)).toList
-
-          val (next, elapsed) = running.minBy(_._2.ms)
-          val (remaining, finished) =
-            running.toList.map(pass_time(elapsed)).partition(_._2 > Time.zero)
-
-          val running1 =
-            remaining.map(pass_time(elapsed)).toMap ++
-              finished.map(_._1).flatMap(get_next).map(start)
-          val (res, running2) = parallel_paths(running1)
-          (res max running.size, running2)
-        }
-
-      parallel_paths(running.toMap)._1
-    }
-  }
-
-
   object Path_Time_Heuristic {
     sealed trait Critical_Criterion
     case class Absolute_Time(time: Time) extends Critical_Criterion {
       override def toString: String = "absolute time (" + time.message_hms + ")"
     }

     is_critical: Path_Time_Heuristic.Critical_Criterion,
     parallel_threads: Path_Time_Heuristic.Parallel_Strategy,
     host_criterion: Path_Time_Heuristic.Host_Criterion,
     timing_data: Timing_Data,
     sessions_structure: Sessions.Structure,
-    build_uuid: String,
     max_threads_limit: Int = 8
-  ) extends Path_Heuristic(timing_data, sessions_structure, max_threads_limit, build_uuid) {
+  ) extends Priority_Rule {
     import Path_Time_Heuristic.*
 
     override def toString: Node = {
       val params =
         List(

           "parallel: " + parallel_threads,
           "fast hosts: " + host_criterion)
       "path time heuristic (" + params.mkString(", ") + ")"
     }
 
-    def next(state: Build_Process.State): List[Config] = {
+    /* pre-computed properties for efficient heuristic */
+    val host_infos = timing_data.host_infos
+    val ordered_hosts = host_infos.hosts.sorted(host_infos.host_speeds)
+
+    val max_threads = host_infos.hosts.map(_.info.num_cpus).max min max_threads_limit
+
+    type Node = String
+    val build_graph = sessions_structure.build_graph
+
+    val minimals = build_graph.minimals
+    val maximals = build_graph.maximals
+
+    def all_preds(node: Node): Set[Node] = build_graph.all_preds(List(node)).toSet
+    val maximals_all_preds = maximals.map(node => node -> all_preds(node)).toMap
+
+    def best_time(node: Node): Time = {
+      val host = ordered_hosts.last
+      val threads = timing_data.best_threads(node, max_threads) min host.info.num_cpus
+      timing_data.estimate(node, host.name, threads)
+    }
+    val best_times = build_graph.keys.map(node => node -> best_time(node)).toMap
+
+    val succs_max_time_ms = build_graph.node_height(best_times(_).ms)
+    def max_time(node: Node): Time = Time.ms(succs_max_time_ms(node)) + best_times(node)
+    def max_time(task: Build_Process.Task): Time = max_time(task.name)
+
+    def path_times(minimals: List[Node]): Map[Node, Time] = {
+      def time_ms(node: Node): Long = best_times(node).ms
+      val path_times_ms = build_graph.reachable_length(time_ms, build_graph.imm_succs, minimals)
+      path_times_ms.view.mapValues(Time.ms).toMap
+    }
+
+    def path_max_times(minimals: List[Node]): Map[Node, Time] =
+      path_times(minimals).toList.map((node, time) => node -> (time + max_time(node))).toMap
+
+    def parallel_paths(running: List[(Node, Time)], pred: Node => Boolean = _ => true): Int = {
+      def start(node: Node): (Node, Time) = node -> best_times(node)
+
+      def pass_time(elapsed: Time)(node: Node, time: Time): (Node, Time) =
+        node -> (time - elapsed)
+
+      def parallel_paths(running: Map[Node, Time]): (Int, Map[Node, Time]) =
+        if (running.isEmpty) (0, running)
+        else {
+          def get_next(node: Node): List[Node] =
+            build_graph.imm_succs(node).filter(pred).filter(
+              build_graph.imm_preds(_).intersect(running.keySet) == Set(node)).toList
+
+          val (next, elapsed) = running.minBy(_._2.ms)
+          val (remaining, finished) =
+            running.toList.map(pass_time(elapsed)).partition(_._2 > Time.zero)
+
+          val running1 =
+            remaining.map(pass_time(elapsed)).toMap ++
+              finished.map(_._1).flatMap(get_next).map(start)
+          val (res, running2) = parallel_paths(running1)
+          (res max running.size, running2)
+        }
+
+      parallel_paths(running.toMap)._1
+    }
+
+    def select_next(state: Build_Process.State): List[Config] = {
       val resources = host_infos.available(state)
 
       def best_threads(task: Build_Process.Task): Int =
         timing_data.best_threads(task.name, max_threads)
 

         val current = state.next_ready.filter(task => is_current(state, task.name))
         if (current.nonEmpty) current.map(_.name)
         else {
           val start = Time.now()
 
-          val new_schedule = scheduler.build_schedule(state).update(state)
+          val new_schedule = scheduler.schedule(state).update(state)
           val schedule =
             if (_schedule.is_empty) new_schedule
             else List(_schedule.update(state), new_schedule).minBy(_.end)(Date.Ordering)
 
           val elapsed = Time.now() - start

         for {
           is_critical <- is_criticals
           parallel <- parallel_threads
           machine_split <- machine_splits
         } yield
-          Path_Time_Heuristic(is_critical, parallel, machine_split, timing_data, sessions_structure,
-            context.build_uuid)
-      val default_heuristic =
-        Default_Heuristic(timing_data, context.build_options, context.build_uuid)
-      new Meta_Heuristic(default_heuristic :: path_time_heuristics)
+          Path_Time_Heuristic(is_critical, parallel, machine_split, timing_data, sessions_structure)
+      val default_heuristic = Default_Heuristic(timing_data.host_infos, context.build_options)
+      val heuristics = default_heuristic :: path_time_heuristics
+      Optimizer(heuristics.map(Generation_Scheme(_, timing_data, context.build_uuid)))
     }
 
     override def open_build_process(
       context: Build.Context,
       progress: Progress,

 
       val scheduler = build_engine.scheduler(timing_data, build_context)
       def schedule_msg(res: Exn.Result[Schedule]): String =
         res match { case Exn.Res(schedule) => schedule.message case _ => "" }
 
-      Timing.timeit(scheduler.build_schedule(build_state), schedule_msg, output = progress.echo(_))
+      Timing.timeit(scheduler.schedule(build_state), schedule_msg, output = progress.echo(_))
     }
 
     using(store.open_server()) { server =>
       using_optional(store.maybe_open_database_server(server = server)) { database_server =>
         using(log_store.open_database(server = server)) { log_database =>