address reviewer comments

Signed-off-by: Bangtian Liu <liubangtian@gmail.com>

Author: bangtianliu

README.md

@@ -181,23 +181,7 @@ Pass custom IREE compiler flags using:
 - **C++ driver**: `FUSILLI_EXTRA_COMPILER_FLAGS` environment variable
 - **Python wrapper**: `--Xiree-compile` flag (which sets the environment variable internally)
 
-**Single flag examples:**
-
-C++ driver:
-```shell
-FUSILLI_EXTRA_COMPILER_FLAGS="--iree-opt-level=O3" \
-  build/bin/benchmarks/fusilli_benchmark_driver --iter 100 \
-  matmul -M 8192 -N 2048 -K 4096 --transA --a_type bf16 --b_type bf16 --out_type bf16
-```
-
-Python wrapper:
-```shell
-python benchmarks/run_benchmark.py \
-  --Xiree-compile="--iree-opt-level=O3" \
-  -f commands.txt -o results.csv
-```
-
-**Multiple flags:**
+**Examples:**
 
 C++ driver (space-separated in one string):
 ```shell

tests/test_compile_session.cpp

@@ -13,14 +13,43 @@
 #include <catch2/matchers/catch_matchers_string.hpp>
 
 #include <algorithm>
+#include <cassert>
 #include <filesystem>
+#include <fstream>
 #include <string>
 #include <vector>
 
 using namespace fusilli;
 
 static std::string kGraphName = "test_compile_session";
 
+// Returns the path to a shared tuning spec file for tests. The file is created
+// once and persists for the process lifetime because IREE caches parsed tuning
+// specs on the dialect instance keyed by path, and the tuning spec flag itself
+// is a process-wide static. Deleting the file would break subsequent
+// compilations that hit the cached path.
+static std::filesystem::path getTestTuningSpecPath() {
+  static std::filesystem::path path = [] {
+    std::filesystem::path dir =
+        std::filesystem::temp_directory_path() / "fusilli_test_tuning_specs";
+    std::filesystem::create_directories(dir);
+    std::filesystem::path p = dir / "tuning_spec.mlir";
+    std::ofstream ofs(p);
+    assert(ofs.is_open() && "Failed to create test tuning spec file");
+    ofs << R"(
+module attributes {transform.with_named_sequence} {
+  transform.named_sequence @__kernel_config(%arg0: !transform.any_op {transform.consumed})
+    -> !transform.any_op attributes {iree_codegen.tuning_spec_entrypoint} {
+    transform.yield %arg0 : !transform.any_op
+  }
+}
+)";
+    ofs.close();
+    return p;
+  }();
+  return path;
+}
+
 TEST_CASE("CompileContext::create successfully loads library",
           "[CompileContext]") {
   // Get the shared compiler context.
@@ -530,10 +559,9 @@ TEST_CASE("CompileSession::addFlag with tuning spec path",
   FUSILLI_REQUIRE_ASSIGN(CompileSession session,
                          context->createSession(handle));
 
-  std::string tuningSpecPath = "/tmp/test_tuning_spec.mlir";
-
   ErrorObject result =
-      session.addFlag("--iree-codegen-tuning-spec-path=" + tuningSpecPath);
+      session.addFlag("--iree-codegen-tuning-spec-path=" +
+                      getTestTuningSpecPath().generic_string());
   FUSILLI_REQUIRE_OK(result);
 
   const std::vector<std::string> &args = session.getArgs();
@@ -553,35 +581,32 @@ TEST_CASE("CompileSession::compile with tuning spec",
   FUSILLI_REQUIRE_ASSIGN(CompileSession session,
                          context->createSession(handle));
 
-  // Create a minimal no-op tuning spec.
-  FUSILLI_REQUIRE_ASSIGN(
-      CacheFile tuningSpec,
-      CacheFile::create(kGraphName, "test_tuning_spec.mlir", /*remove=*/true));
-
-  std::string tuningSpecContent = R"(
-module attributes {transform.with_named_sequence} {
-  transform.named_sequence @__kernel_config(%arg0: !transform.any_op {transform.consumed})
-    -> !transform.any_op attributes {iree_codegen.tuning_spec_entrypoint} {
-    transform.yield %arg0 : !transform.any_op
-  }
-}
-)";
-  FUSILLI_REQUIRE_OK(tuningSpec.write(tuningSpecContent));
-
   FUSILLI_REQUIRE_OK(session.addFlag("--iree-codegen-tuning-spec-path=" +
-                                     tuningSpec.path.string()));
+                                     getTestTuningSpecPath().generic_string()));
+
+  // Create input/output files in cache (these will auto-cleanup with
+  // remove=true).
+  std::string graphName = "test_compile_session_with_tuning_spec";
   FUSILLI_REQUIRE_ASSIGN(
       CacheFile input,
-      CacheFile::create(kGraphName, "input_with_spec.mlir", /*remove=*/true));
+      CacheFile::create(graphName, "input.mlir", /*remove=*/true));
   FUSILLI_REQUIRE_ASSIGN(
       CacheFile output,
-      CacheFile::create(kGraphName, "output_with_spec.vmfb", /*remove=*/true));
+      CacheFile::create(graphName, "output.vmfb", /*remove=*/true));
 
-  std::string mlirContent = getSimpleMLIRModule();
+  // Write a simple MLIR module to the input file.
+  std::string mlirContent = R"(
+module {
+  func.func @tuning_spec_test(%arg0: tensor<3x3xf32>, %arg1: tensor<3x3xf32>) -> tensor<3x3xf32> {
+    %0 = arith.mulf %arg0, %arg1 : tensor<3x3xf32>
+    return %0 : tensor<3x3xf32>
+  }
+}
+)";
   FUSILLI_REQUIRE_OK(input.write(mlirContent));
 
-  ErrorObject compileResult =
-      session.compile(input.path.string(), output.path.string());
+  ErrorObject compileResult = session.compile(input.path.generic_string(),
+                                              output.path.generic_string());
   FUSILLI_REQUIRE_OK(compileResult);
   REQUIRE(std::filesystem::exists(output.path));
   REQUIRE(std::filesystem::file_size(output.path) > 0);