Choose the checker count from CPUs and program size

The checker count was fixed at 4 because which checker checked a file
could change the results, so changing it changed the output. That is no
longer the case, and with checkers taking files from each other it only
trades time for memory, so the default can follow the machine.

Checking is fastest with about one checker per CPU, until the work
every checker duplicates (library and shared types) outweighs what
another checker adds. Measured on 4 and 8 CPUs, one checker per logical
CPU was fastest for nearly every project, hyperthreads included; on 20
CPUs, 8 checkers were fastest for most projects, and only very large
programs gained up to 12-16. So the default is one checker per CPU, up
to 8, rising with the square root of the checked work up to 16, and no
more than one per 32 checked files, but at least the 4 of before when
there are as many CPUs. Files whose checking is skipped, such as
declaration files under skipLibCheck, count for nothing.

Build mode divides the CPUs among the projects it builds concurrently,
but never gives a project fewer than the 4 checkers of before, since
projects that depend on each other are built one at a time.

Author: jakebailey

tools/scripts/tsc/options.ts

@@ -1697,7 +1697,7 @@ export const options: OptionsModel = {
                 group: "commonOptionsWithBuild",
                 category: diagnostic("Command-line Options"),
                 description: diagnostic("Set the number of checkers per project."),
-                defaultValueDescription: diagnostic("4, unless --singleThreaded is passed."),
+                defaultValueDescription: diagnostic("Based on the available CPUs and the size of the project, unless --singleThreaded is passed."),
                 minValue: 1,
             },
         },

tsc/internal/compiler/checkerpool.go

@@ -3,6 +3,7 @@ package compiler
 import (
 	"context"
 	"math"
+	"runtime"
 	"slices"
 	"sort"
 	"sync"
@@ -305,6 +306,57 @@ func getCheckerAssociationWeights(baseWeights []int, importCounts []int) []int {
 	return fileWeights
 }
 
+/*
+defaultCheckerCount picks the number of checkers when none is given. Which
+checker checks a file does not change the results, and checkers take files
+from each other once out of their own, so the count only trades time for
+memory. Each checker builds much the same library and shared types, so
+every checker adds work and memory of its own, and checking is fastest with
+about one checker per CPU, up to the point where that duplicated work
+dominates:
+
+  - With 4 or 8 CPUs, measured with the process restricted to them, one
+    checker per logical CPU was fastest for nearly every project, and
+    hyperthreads were nearly as good as cores.
+  - With 20 CPUs (10 cores), 8 checkers were fastest for most projects;
+    only very large programs (VS Code) gained up to 12-16.
+  - Programs with few checked files gain nothing from more checkers than a
+    few files each, but even those with a few dozen files gain from the 4
+    checkers that were the default before.
+
+Work is estimated from the files that are checked: those whose checking is
+skipped, such as declaration files under skipLibCheck, count for nothing.
+*/
+func defaultCheckerCount(program *Program) int {
+	procs := program.opts.CheckerProcs
+	if procs <= 0 {
+		procs = runtime.GOMAXPROCS(0)
+	}
+	files, weight := 0, 0
+	for _, file := range program.files {
+		if !program.SkipTypeChecking(file, true /*ignoreNoCheck*/) {
+			files++
+			weight += getCheckerAssociationBaseWeight(file.NodeCount, len(file.Text()))
+		}
+	}
+	limit := min(max(int(defaultCheckerLimit*math.Sqrt(float64(weight)/defaultCheckerLimitWeight)), defaultCheckerLimit), maxDefaultCheckerLimit)
+	return max(min(procs, limit, (files+filesPerChecker-1)/filesPerChecker), min(procs, minDefaultCheckers))
+}
+
+const (
+	// defaultCheckerLimit is the checker count past which more checkers stop
+	// paying for their duplicated work, for programs up to
+	// defaultCheckerLimitWeight of checked work. Larger programs get more, up
+	// to maxDefaultCheckerLimit, with the square root of their size.
+	defaultCheckerLimit       = 8
+	defaultCheckerLimitWeight = 8_000_000
+	maxDefaultCheckerLimit    = 16
+	// filesPerChecker is the number of checked files below which another
+	// checker does not pay for itself, above minDefaultCheckers.
+	filesPerChecker    = 32
+	minDefaultCheckers = 4
+)
+
 func newCheckerPool(program *Program) *checkerPool {
 	return newCheckerPoolWithTracing(program, nil)
 }
@@ -317,7 +369,7 @@ func newCheckerPoolWithTracing(program *Program, tr *tracing.Tracing) *checkerPo
 // of each file given by assign, if set; see ProgramFactories.AssignCheckers.
 func newCheckerPoolWithAssignment(program *Program, tr *tracing.Tracing, assign func([]*ast.SourceFile) []int) *checkerPool {
 	var associations []int
-	checkerCount := 4
+	var checkerCount int
 	if assign != nil {
 		associations = assign(program.files)
 		checkerCount = 1
@@ -329,6 +381,8 @@ func newCheckerPoolWithAssignment(program *Program, tr *tracing.Tracing, assign
 			checkerCount = 1
 		} else if c := program.Options().Checkers; c != nil {
 			checkerCount = *c
+		} else {
+			checkerCount = defaultCheckerCount(program)
 		}
 		checkerCount = max(min(checkerCount, len(program.files), 256), 1)
 	}

tsc/internal/compiler/program.go

@@ -50,6 +50,10 @@ type ProgramConfig struct {
 	// SkipModuleResolution avoids all module and type reference resolution while
 	// still collecting import metadata needed for emit.
 	SkipModuleResolution bool
+	// CheckerProcs is the number of CPUs the checkers of the program may use
+	// when no checker count is given, or 0 for GOMAXPROCS; see
+	// defaultCheckerCount.
+	CheckerProcs int
 }
 
 type ProgramHosts struct {

tsc/internal/diagnostics/diagnosticMessages.generated.json

@@ -1696,6 +1696,7 @@
     "Set_the_number_of_projects_to_build_concurrently_6938": "Set the number of projects to build concurrently.",
     "Deduplicate_packages_with_the_same_name_and_version_6939": "Deduplicate packages with the same name and version.",
     "Allow_loading_external_content_mapper_plugins_that_execute_code_during_compilation_6940": "Allow loading external content mapper plugins that execute code during compilation.",
+    "Based_on_the_available_CPUs_and_the_size_of_the_project_unless_singleThreaded_is_passed_6941": "Based on the available CPUs and the size of the project, unless --singleThreaded is passed.",
     "Variable_0_implicitly_has_an_1_type_7005": "Variable '{0}' implicitly has an '{1}' type.",
     "Parameter_0_implicitly_has_an_1_type_7006": "Parameter '{0}' implicitly has an '{1}' type.",
     "Member_0_implicitly_has_an_1_type_7008": "Member '{0}' implicitly has an '{1}' type.",

tsc/internal/diagnostics/diagnosticMessages.json

@@ -6807,6 +6807,10 @@
         "category": "Message",
         "code": 6937
     },
+    "Based on the available CPUs and the size of the project, unless --singleThreaded is passed.": {
+        "category": "Message",
+        "code": 6941
+    },
     "Set the number of projects to build concurrently.": {
         "category": "Message",
         "code": 6938

tsc/internal/diagnostics/diagnostics_generated.go

@@ -249,8 +249,9 @@ func (t *BuildTask) compileAndEmit(orchestrator *Orchestrator, path tspath.PathK
 	compileTimes.BuildInfoReadTime = orchestrator.opts.Sys.Now().Sub(buildInfoReadStart)
 	parseStart := orchestrator.opts.Sys.Now()
 	program := compiler.NewProgram(compiler.ProgramOptions{
-		Config: t.resolved,
-		Host:   compilerHost,
+		Config:       t.resolved,
+		CheckerProcs: orchestrator.checkerProcs(),
+		Host:         compilerHost,
 	})
 	compileTimes.ParseTime = orchestrator.opts.Sys.Now().Sub(parseStart)
 	changesComputeStart := orchestrator.opts.Sys.Now()

tsc/internal/execute/build/buildtask.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"runtime"
 	"slices"
 	"strings"
 	"sync/atomic"
@@ -918,13 +919,26 @@ func (o *Orchestrator) rangeTask(f func(path tspath.PathKey, task *BuildTask)) {
 	o.rangeTasks(o.order, f)
 }
 
-func (o *Orchestrator) rangeTasks(order []*BuildTask, f func(path tspath.PathKey, task *BuildTask)) {
-	numRoutines := 4
+// builderCount returns the number of projects built concurrently.
+func (o *Orchestrator) builderCount() int {
 	if o.opts.Command.CompilerOptions.SingleThreaded.IsTrue() {
-		numRoutines = 1
+		return 1
 	} else if builders := o.opts.Command.BuildOptions.Builders; builders != nil {
-		numRoutines = *builders
+		return *builders
 	}
+	return 4
+}
+
+// checkerProcs returns the CPUs the checkers of each project may use: an
+// equal share among the projects built concurrently, but no fewer than the 4
+// checkers of before, since projects that depend on each other are built one
+// at a time, and the share would leave the rest of the CPUs idle.
+func (o *Orchestrator) checkerProcs() int {
+	return max(runtime.GOMAXPROCS(0)/max(o.builderCount(), 1), 4)
+}
+
+func (o *Orchestrator) rangeTasks(order []*BuildTask, f func(path tspath.PathKey, task *BuildTask)) {
+	numRoutines := o.builderCount()
 
 	var currentTaskIndex atomic.Int64
 	getNextTask := func() (tspath.PathKey, *BuildTask, bool) {