Keep a small reserve of tasks to not-batch, so all threads can have always have an initial task (microsoft#18696)

weswigham · web-flow · commit 5f4436d43385 · 2017-09-22T14:44:26.000-07:00
* Keep a small reserve of tasks to not-batch, so all threads can have an initial task"

* Assign no weight to new tests, but still place them at the end of the list
diff --git a/src/harness/parallel/host.ts b/src/harness/parallel/host.ts
@@ -44,7 +44,8 @@ namespace Harness.Parallel.Host {
         console.log("Discovering tests...");
         const discoverStart = +(new Date());
         const { statSync }: { statSync(path: string): { size: number }; } = require("fs");
-        const tasks: { runner: TestRunnerKind, file: string, size: number }[] = [];
+        let tasks: { runner: TestRunnerKind, file: string, size: number }[] = [];
+        const newTasks: { runner: TestRunnerKind, file: string, size: number }[] = [];
         const perfData = readSavedPerfData();
         let totalCost = 0;
         let unknownValue: string | undefined;
@@ -60,15 +61,18 @@ namespace Harness.Parallel.Host {
                     const hashedName = hashName(runner.kind(), file);
                     size = perfData[hashedName];
                     if (size === undefined) {
-                        size = Number.MAX_SAFE_INTEGER;
+                        size = 0;
                         unknownValue = hashedName;
+                        newTasks.push({ runner: runner.kind(), file, size });
+                        continue;
                     }
                 }
                 tasks.push({ runner: runner.kind(), file, size });
                 totalCost += size;
             }
         }
         tasks.sort((a, b) => a.size - b.size);
+        tasks = tasks.concat(newTasks);
         // 1 fewer batches than threads to account for unittests running on the final thread
         const batchCount = runners.length === 1 ? workerCount : workerCount - 1;
         const packfraction = 0.9;
@@ -174,7 +178,7 @@ namespace Harness.Parallel.Host {
             let scheduledTotal = 0;
             batcher: while (true) {
                 for (let i = 0; i < batchCount; i++) {
-                    if (tasks.length === 0) {
+                    if (tasks.length <= workerCount) { // Keep a small reserve even in the suboptimally packed case
                         console.log(`Suboptimal packing detected: no tests remain to be stolen. Reduce packing fraction from ${packfraction} to fix.`);
                         break batcher;
                     }
@@ -213,7 +217,9 @@ namespace Harness.Parallel.Host {
                     worker.send({ type: "batch", payload });
                 }
                 else { // Unittest thread - send off just one test
-                    worker.send({ type: "test", payload: tasks.pop() });
+                    const payload = tasks.pop();
+                    ts.Debug.assert(!!payload); // The reserve kept above should ensure there is always an initial task available, even in suboptimal scenarios
+                    worker.send({ type: "test", payload });
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,8 @@ namespace Harness.Parallel.Host {`
`44`	`44`	`console.log("Discovering tests...");`
`45`	`45`	`const discoverStart = +(new Date());`
`46`	`46`	`const { statSync }: { statSync(path: string): { size: number }; } = require("fs");`
`47`		`- const tasks: { runner: TestRunnerKind, file: string, size: number }[] = [];`
	`47`	`+ let tasks: { runner: TestRunnerKind, file: string, size: number }[] = [];`
	`48`	`+ const newTasks: { runner: TestRunnerKind, file: string, size: number }[] = [];`
`48`	`49`	`const perfData = readSavedPerfData();`
`49`	`50`	`let totalCost = 0;`
`50`	`51`	`let unknownValue: string \| undefined;`
`@@ -60,15 +61,18 @@ namespace Harness.Parallel.Host {`
`60`	`61`	`const hashedName = hashName(runner.kind(), file);`
`61`	`62`	`size = perfData[hashedName];`
`62`	`63`	`if (size === undefined) {`
`63`		`- size = Number.MAX_SAFE_INTEGER;`
	`64`	`+ size = 0;`
`64`	`65`	`unknownValue = hashedName;`
	`66`	`+ newTasks.push({ runner: runner.kind(), file, size });`
	`67`	`+ continue;`
`65`	`68`	`}`
`66`	`69`	`}`
`67`	`70`	`tasks.push({ runner: runner.kind(), file, size });`
`68`	`71`	`totalCost += size;`
`69`	`72`	`}`
`70`	`73`	`}`
`71`	`74`	`tasks.sort((a, b) => a.size - b.size);`
	`75`	`+ tasks = tasks.concat(newTasks);`
`72`	`76`	`// 1 fewer batches than threads to account for unittests running on the final thread`
`73`	`77`	`const batchCount = runners.length === 1 ? workerCount : workerCount - 1;`
`74`	`78`	`const packfraction = 0.9;`
`@@ -174,7 +178,7 @@ namespace Harness.Parallel.Host {`
`174`	`178`	`let scheduledTotal = 0;`
`175`	`179`	`batcher: while (true) {`
`176`	`180`	`for (let i = 0; i < batchCount; i++) {`
`177`		`- if (tasks.length === 0) {`
	`181`	`+ if (tasks.length <= workerCount) { // Keep a small reserve even in the suboptimally packed case`
`178`	`182`	console.log(`Suboptimal packing detected: no tests remain to be stolen. Reduce packing fraction from ${packfraction} to fix.`);
`179`	`183`	`break batcher;`
`180`	`184`	`}`
`@@ -213,7 +217,9 @@ namespace Harness.Parallel.Host {`
`213`	`217`	`worker.send({ type: "batch", payload });`
`214`	`218`	`}`
`215`	`219`	`else { // Unittest thread - send off just one test`
`216`		`- worker.send({ type: "test", payload: tasks.pop() });`
	`220`	`+ const payload = tasks.pop();`
	`221`	`+ ts.Debug.assert(!!payload); // The reserve kept above should ensure there is always an initial task available, even in suboptimal scenarios`
	`222`	`+ worker.send({ type: "test", payload });`
`217`	`223`	`}`
`218`	`224`	`}`
`219`	`225`	`}`