Drop release branches from master.cfg (#320)

* Remove _HALIDE_RELEASES table
* Remove LLVM_FOR_HALIDE table
* Inline HALIDE_MAIN
* Constant-propagate "main" and HALIDE_BRANCHES
* Reduce treeStableTimer to 3 minutes

Author: alexreinking

master/master.cfg

@@ -7,6 +7,7 @@ import operator
 import os
 import re
 from collections import defaultdict
+from datetime import timedelta
 from dataclasses import dataclass
 from functools import reduce
 from pathlib import Path
@@ -108,38 +109,6 @@ LLVM_BRANCHES = {
     LLVM_RELEASE_20: VersionedBranch(ref="llvmorg-20.1.8", version=Version(20, 1, 8)),
 }
 
-# At any given time, Halide has a main branch, which supports (at least)
-# the LLVM main branch and the most recent release branch (and maybe one older).
-#
-# We also support previous release branches; a release branch tracks *only* the
-# corresponding version of LLVM (i.e., Halide 13 is 'release/13.x' and is only
-# built/tested against LLVM13, even though it might still work with other LLVM versions).
-#
-# Note that we deliberately chose branch names that match LLVM's conventions.
-#
-# (Note that there are older releases of Halide that we no longer bother to build/test regularly.)
-
-HALIDE_MAIN = "main"
-HALIDE_RELEASE_21 = "release_21"
-
-_HALIDE_RELEASES = [
-    HALIDE_RELEASE_21,
-]
-
-HALIDE_BRANCHES = {
-    HALIDE_MAIN: VersionedBranch(ref="main", version=Version(22, 0, 0)),
-    HALIDE_RELEASE_21: VersionedBranch(ref="release/21.x", version=Version(21, 0, 0)),
-}
-
-# Given a halide branch, return the 'native' llvm version we expect to use with it.
-# For halide release branches, this is the corresponding llvm release branch; for
-# halide main, it's llvm main.
-LLVM_FOR_HALIDE = {
-    HALIDE_MAIN: [LLVM_MAIN, LLVM_RELEASE_22, LLVM_RELEASE_21, LLVM_RELEASE_20],
-    HALIDE_RELEASE_21: [LLVM_RELEASE_21],
-}
-
-
 # WORKERS
 
 # The 'workers' list defines the set of recognized buildworkers. Each element is
@@ -205,7 +174,7 @@ class BuilderType:
     setup. (If we ever need to do so, compiler should be added to this.)
     """
 
-    def __init__(self, arch, bits, os, halide_branch, llvm_branch, sanitizer=None):
+    def __init__(self, arch, bits, os, llvm_branch, sanitizer=None):
         assert arch in ["arm", "x86"]
         assert bits in [32, 64]
         assert os in ["linux", "windows", "osx"]
@@ -214,13 +183,9 @@ class BuilderType:
         self.arch = arch
         self.bits = bits
         self.os = os
-        self.halide_branch = halide_branch
         self.llvm_branch = llvm_branch
         self.sanitizer = sanitizer
 
-        assert self.halide_branch, "halide_branch is required"
-        assert self.halide_branch in HALIDE_BRANCHES, f"unknown branch {self.halide_branch}"
-
         if self.sanitizer:
             assert self.sanitizer in _SANITIZERS
 
@@ -305,11 +270,7 @@ class BuilderType:
         a = ["halide"]
         if self.sanitizer:
             a.append(self.sanitizer)
-        a.append(self.halide_branch)
-        if self.halide_branch == HALIDE_MAIN:
-            # Halide master is built against multiple LLVM versions,
-            # so append that here for clarity
-            a.append(f"llvm_{LLVM_BRANCHES[self.llvm_branch].shortversion}")
+        a.append(f"llvm_{LLVM_BRANCHES[self.llvm_branch].shortversion}")
         a.append(self.halide_target())
         return "-".join(a)
 
@@ -343,14 +304,14 @@ def get_install_path(builder_type, *subpaths):
     return get_builddir_subpath(os.path.join(s, *subpaths))
 
 
-def add_get_source_steps(factory, builder_type):
+def add_get_source_steps(factory):
     factory.addStep(
         GitHub(
             name="Get Halide source",
             locks=[performance_lock.access("counting")],
             workdir=get_source_path(),
             repourl="https://github.com/halide/Halide.git",
-            branch=HALIDE_BRANCHES[builder_type.halide_branch].ref,
+            branch="main",
             mode="incremental",
         )
     )
@@ -1228,7 +1189,7 @@ def add_test_steps(factory, builder_type):
 def create_build_factory(builder_type):
     factory = BuildFactory()
     add_env_setup_step(factory, builder_type)
-    add_get_source_steps(factory, builder_type)
+    add_get_source_steps(factory)
     add_create_venv_step(factory, builder_type)
     add_install_llvm_step(factory, builder_type)
     add_build_steps(factory, builder_type)
@@ -1249,7 +1210,7 @@ def get_interesting_targets():
                 yield arch, bits, os
 
 
-def create_builder(arch, bits, os, halide_branch, llvm_branch):
+def create_builder(arch, bits, os, llvm_branch):
     # Always do a build with no sanitizers
     sanitizers = [None]
 
@@ -1258,7 +1219,7 @@ def create_builder(arch, bits, os, halide_branch, llvm_branch):
     # sanitizers.extend(_SANITIZERS)
 
     for san in sanitizers:
-        builder_type = BuilderType(arch, bits, os, halide_branch, llvm_branch, san)
+        builder_type = BuilderType(arch, bits, os, llvm_branch, san)
         if san and not builder_type.handles_sanitizers():
             continue
 
@@ -1275,54 +1236,34 @@ def create_builder(arch, bits, os, halide_branch, llvm_branch):
 
 
 def create_builders():
+    # Create the builders for testing pull requests to main.
     for arch, bits, os in get_interesting_targets():
-        # Create the builders for testing pull requests to releases.
-        for halide_branch in _HALIDE_RELEASES:
-            for llvm_branch in LLVM_FOR_HALIDE[halide_branch]:
-                yield from create_builder(arch, bits, os, halide_branch, llvm_branch)
-
-        # Create the builders for testing pull requests to main.
-        yield from create_builder(arch, bits, os, HALIDE_MAIN, LLVM_MAIN)
+        yield from create_builder(arch, bits, os, LLVM_MAIN)
 
     # Test pull requests for Halide master against the current and previous LLVM, for at least one target.
     for llvm_branch in LLVM_BRANCHES:
         if llvm_branch != LLVM_MAIN:
-            yield from create_builder("x86", 64, "linux", HALIDE_MAIN, llvm_branch)
-
-
-def create_scheduler(halide_branch):
-    def is_base_branch(br):
-        return any(br == hl.ref for hl in HALIDE_BRANCHES.values())
-
-    def is_pr_branch(br):
-        # If it's not one of the well-known branches, assume it's a pull request
-        return not is_base_branch(br)
-
-    def github_base_branch_matches(change):
-        ref = change.properties.getProperty("basename")
-        return ref == HALIDE_BRANCHES[halide_branch].ref
-
-    builders = [b for b in c["builders"] if b.builder_type.halide_branch == halide_branch]
-    if builders:
-        # NOT SingleBranchScheduler, because this can process changes from many branches (all PRs)
-        builder_names = [str(b.name) for b in builders]
-        yield AnyBranchScheduler(
-            name="halide-" + halide_branch,
-            change_filter=ChangeFilter(category="pull", branch_fn=is_pr_branch, filter_fn=github_base_branch_matches),
-            treeStableTimer=60 * 5,  # seconds
-            builderNames=builder_names,
-        )
-
-        yield ForceScheduler(name="force-halide-" + halide_branch, builderNames=builder_names)
-
-
-def create_schedulers():
-    for halide_branch in HALIDE_BRANCHES:
-        yield from create_scheduler(halide_branch)
+            yield from create_builder("x86", 64, "linux", llvm_branch)
 
 
 c["builders"] = list(create_builders())
-c["schedulers"] = list(create_schedulers())
+
+c["schedulers"] = [
+    AnyBranchScheduler(
+        name="halide-main",
+        change_filter=ChangeFilter(
+            category="pull",
+            branch_fn=lambda br: br != "main",
+            filter_fn=lambda ch: ch.properties.getProperty("basename") == "main",
+        ),
+        treeStableTimer=timedelta(minutes=3).total_seconds(),
+        builderNames=[b1.name for b1 in c["builders"]],
+    ),
+    ForceScheduler(
+        name="force-halide-main",
+        builderNames=[b1.name for b1 in c["builders"]],
+    ),
+]
 
 
 # GitHub pull request filter