a few optimization to static-cpp generator (#3)

* output file content hash in index_impl.h

* only write to file if changed

* update tests

Author: fs-eire

src/code-generator-static-impl.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { WgslTemplateBuildError } from "./errors.js";
 import type {
   SourceBuilder,
@@ -188,6 +189,7 @@ export class StaticCodeGenerator implements CodeGenerator, SourceBuilder {
 
   #buildGenerateIndexImpl(
     repo: TemplateRepository<TemplatePass2>,
+    templateImplementationHash: Map<string, string>,
     includePathPrefix: string,
     templateExt: string
   ): string {
@@ -238,7 +240,14 @@ std::string pass_as_string(T&& v) {
         throw new Error(`Template name "${name}" does not end with the expected extension "${templateExt}"`);
       }
       const baseName = name.slice(0, -templateExt.length);
-      implContent.push(`#include "${includePathPrefix}generated/${baseName}.h"`);
+      const hash = templateImplementationHash.get(name);
+      if (!hash) {
+        throw new WgslTemplateBuildError(
+          `Missing hash for template implementation "${name}"`,
+          "output-validation-failed"
+        );
+      }
+      implContent.push(`#include "${includePathPrefix}generated/${baseName}.h"  // ${hash}`);
     }
 
     implContent.push("");
@@ -303,28 +312,36 @@ std::string pass_as_string(T&& v) {
     options: SourceBuilderOptions
   ): TemplateRepository<TemplateBuildResult> {
     const result = new Map<string, TemplateBuildResult>();
+    const templateImplementationHash = new Map<string, string>();
 
-    // STEP.1. Generate the index.h
-    result.set("index.h", this.#buildGenerateIndex(repo));
-
-    // STEP.2. Generate the string table if needed
-    if (this.#stringTable) {
-      result.set("string_table.h", this.#buildGenerateStringTable());
+    // STEP.1. Generate each template implementation
+    for (const [name, template] of repo.templates) {
+      if (!name.endsWith(options.templateExt)) {
+        throw new Error(`Template name "${name}" does not end with the expected extension "${options.templateExt}"`);
+      }
+      const baseName = name.slice(0, -options.templateExt.length);
+      const content = this.#buildTemplateImplementation(name, template);
+      result.set(`generated/${baseName}.h`, content);
+      templateImplementationHash.set(name, createHash("sha256").update(content).digest("hex"));
     }
 
-    // STEP.3. Generate implementation index_impl.h
+    // STEP.2. Generate implementation index_impl.h
     result.set(
       "index_impl.h",
-      this.#buildGenerateIndexImpl(repo, options.includePathPrefix ?? "", options.templateExt)
+      this.#buildGenerateIndexImpl(
+        repo,
+        templateImplementationHash,
+        options.includePathPrefix ?? "",
+        options.templateExt
+      )
     );
 
-    // STEP.4. Generate each template implementation
-    for (const [name, template] of repo.templates) {
-      if (!name.endsWith(options.templateExt)) {
-        throw new Error(`Template name "${name}" does not end with the expected extension "${options.templateExt}"`);
-      }
-      const baseName = name.slice(0, -options.templateExt.length);
-      result.set(`generated/${baseName}.h`, this.#buildTemplateImplementation(name, template));
+    // STEP.3. Generate the index.h
+    result.set("index.h", this.#buildGenerateIndex(repo));
+
+    // STEP.4. Generate the string table if needed
+    if (this.#stringTable) {
+      result.set("string_table.h", this.#buildGenerateStringTable());
     }
 
     return {

src/index.ts

@@ -108,8 +108,19 @@ export const build = async (options: BuildOptions): Promise<BuildResult> => {
         // Create the directory if it doesn't exist
         await fs.mkdir(dirName, { recursive: true });
 
-        // Write the file
-        await fs.writeFile(fullPath, result, "utf8");
+        // Only write the file if content has changed
+        let shouldWrite = true;
+        try {
+          const existingContent = await fs.readFile(fullPath, "utf8");
+          shouldWrite = existingContent !== result;
+        } catch {
+          // File doesn't exist or can't be read, so we should write it
+          shouldWrite = true;
+        }
+
+        if (shouldWrite) {
+          await fs.writeFile(fullPath, result, "utf8");
+        }
 
         // Record successful file write
         await fs.stat(fullPath);

test/testcases/build-basic/expected/static-cpp/index_impl.h

@@ -35,7 +35,7 @@ std::string pass_as_string(T&& v) {
 
 // Include template implementations
 
-#include "generated/shader/triangle.h"
+#include "generated/shader/triangle.h"  // f5cec46558b917d8a4ec739f0ab02e71a31046d9c0d14028daa4aa0557a72da6
 
 #pragma pop_macro("MainFunctionStart")
 #pragma pop_macro("MainFunctionEnd")

test/testcases/build-example-pad/expected/static-cpp-literal/index_impl.h

@@ -34,7 +34,7 @@ std::string pass_as_string(T&& v) {
 
 // Include template implementations
 
-#include "generated/tensor/pad.h"
+#include "generated/tensor/pad.h"  // 6322dc19e1e013413b06fa369e2961e3683123a3f4a36e646798f3219b132f49
 
 #pragma pop_macro("MainFunctionStart")
 #pragma pop_macro("MainFunctionEnd")