fix: automatically resolve compiler is out of heap space CUDA build error

Author: giladgd

src/bindings/utils/compileLLamaCpp.ts

@@ -31,7 +31,7 @@ export async function compileLlamaCpp(buildOptions: BuildOptions, compileOptions
     includeBuildOptionsInBinaryFolderName?: boolean,
     ensureLlamaCppRepoIsCloned?: boolean,
     downloadCmakeIfNeeded?: boolean,
-    ignoreWorkarounds?: ("cudaArchitecture")[],
+    ignoreWorkarounds?: ("cudaArchitecture" | "reduceParallelBuildThreads" | "singleBuildThread")[],
     envVars?: typeof process.env,
     ciMode?: boolean
 }): Promise<void> {
@@ -54,6 +54,12 @@ export async function compileLlamaCpp(buildOptions: BuildOptions, compileOptions
 
     const outDirectory = path.join(llamaLocalBuildBinsDirectory, finalBuildFolderName);
 
+    let parallelBuildThreads = getParallelBuildThreadsToUse(platform);
+    if (ignoreWorkarounds.includes("singleBuildThread"))
+        parallelBuildThreads = 1;
+    else if (ignoreWorkarounds.includes("reduceParallelBuildThreads"))
+        parallelBuildThreads = reduceParallelBuildThreads(parallelBuildThreads);
+
     await fs.mkdirp(llamaLocalBuildBinsDirectory);
     try {
         await withLockfile({
@@ -128,7 +134,7 @@ export async function compileLlamaCpp(buildOptions: BuildOptions, compileOptions
                         "--arch=" + buildOptions.arch,
                         "--out", path.relative(llamaDirectory, outDirectory),
                         "--runtime-version=" + runtimeVersion,
-                        "--parallel=" + getParallelBuildThreadsToUse(platform),
+                        "--parallel=" + parallelBuildThreads,
                         ...cmakePathArgs,
                         ...(
                             [...cmakeCustomOptions].map(([key, value]) => "--CD" + key + "=" + value)
@@ -242,6 +248,38 @@ export async function compileLlamaCpp(buildOptions: BuildOptions, compileOptions
                             console.error(getConsoleLogPrefix(true, false), err);
                     }
                 }
+            } else if (
+                (!ignoreWorkarounds.includes("reduceParallelBuildThreads") || !ignoreWorkarounds.includes("singleBuildThread")) &&
+                (platform === "win" || platform === "linux") &&
+                err instanceof SpawnError &&
+                reduceParallelBuildThreads(parallelBuildThreads) !== parallelBuildThreads &&
+                err.combinedStd.toLowerCase().includes("compiler is out of heap space".toLowerCase())
+            ) {
+                if (buildOptions.progressLogs) {
+                    if (ignoreWorkarounds.includes("reduceParallelBuildThreads"))
+                        console.info(
+                            getConsoleLogPrefix(true) + "Trying to compile again with a single build thread"
+                        );
+                    else
+                        console.info(
+                            getConsoleLogPrefix(true) + "Trying to compile again with reduced parallel build threads"
+                        );
+                }
+
+                try {
+                    return await compileLlamaCpp(buildOptions, {
+                        ...compileOptions,
+                        ignoreWorkarounds: [
+                            ...ignoreWorkarounds,
+                            ignoreWorkarounds.includes("reduceParallelBuildThreads")
+                                ? "singleBuildThread"
+                                : "reduceParallelBuildThreads"
+                        ]
+                    });
+                } catch (err) {
+                    if (buildOptions.progressLogs)
+                        console.error(getConsoleLogPrefix(true, false), err);
+                }
             }
 
             console.info("\n" +
@@ -475,3 +513,7 @@ function getParallelBuildThreadsToUse(platform: BinaryPlatform) {
 
     return cpuCount - 2;
 }
+
+function reduceParallelBuildThreads(originalParallelBuildThreads: number) {
+    return Math.max(1, Math.round(originalParallelBuildThreads / 2));
+}