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

@@ -14,6 +14,7 @@
 
 #include <algorithm>
 #include <filesystem>
+#include <fstream>
 #include <string>
 #include <vector>
 
@@ -530,10 +531,31 @@ TEST_CASE("CompileSession::addFlag with tuning spec path",
   FUSILLI_REQUIRE_ASSIGN(CompileSession session,
                          context->createSession(handle));
 
-  std::string tuningSpecPath = "/tmp/test_tuning_spec.mlir";
+  // Create tuning spec in temp directory (outside cache) to avoid cache
+  // validation issues. IREE registers tuning spec paths globally, so we need
+  // a real file (not a dummy path).
+  std::filesystem::path tempDir =
+      std::filesystem::temp_directory_path() / "fusilli_test_tuning_specs";
+  std::filesystem::create_directories(tempDir);
+  std::filesystem::path tuningSpecPath = tempDir / "test1_tuning_spec.mlir";
 
-  ErrorObject result =
-      session.addFlag("--iree-codegen-tuning-spec-path=" + tuningSpecPath);
+  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
+  }
+}
+)";
+
+  // Write tuning spec file to temp directory.
+  std::ofstream ofs(tuningSpecPath);
+  REQUIRE(ofs.is_open());
+  ofs << tuningSpecContent;
+  ofs.close();
+
+  ErrorObject result = session.addFlag("--iree-codegen-tuning-spec-path=" +
+                                       tuningSpecPath.generic_string());
   FUSILLI_REQUIRE_OK(result);
 
   const std::vector<std::string> &args = session.getArgs();
@@ -542,6 +564,10 @@ TEST_CASE("CompileSession::addFlag with tuning spec path",
         return arg.find("--iree-codegen-tuning-spec-path") != std::string::npos;
       });
   REQUIRE(hasTuningSpecFlag);
+
+  // Note: We don't clean up the temp file here because IREE has process-wide
+  // caching that references this path. Deleting it would break subsequent
+  // tests. The temp directory will be cleaned up by the OS or test runner.
 }
 
 TEST_CASE("CompileSession::compile with tuning spec",
@@ -553,10 +579,12 @@ 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));
+  // Create tuning spec in temp directory (outside cache) to avoid cache
+  // validation issues.
+  std::filesystem::path tempDir =
+      std::filesystem::temp_directory_path() / "fusilli_test_tuning_specs";
+  std::filesystem::create_directories(tempDir);
+  std::filesystem::path tuningSpecPath = tempDir / "test2_tuning_spec.mlir";
 
   std::string tuningSpecContent = R"(
 module attributes {transform.with_named_sequence} {
@@ -566,25 +594,48 @@ module attributes {transform.with_named_sequence} {
   }
 }
 )";
-  FUSILLI_REQUIRE_OK(tuningSpec.write(tuningSpecContent));
+
+  // Write tuning spec file to temp directory.
+  std::ofstream ofs(tuningSpecPath);
+  REQUIRE(ofs.is_open());
+  ofs << tuningSpecContent;
+  ofs.close();
 
   FUSILLI_REQUIRE_OK(session.addFlag("--iree-codegen-tuning-spec-path=" +
-                                     tuningSpec.path.string()));
+                                     tuningSpecPath.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));
-
-  std::string mlirContent = getSimpleMLIRModule();
+      CacheFile::create(graphName, "output.vmfb", /*remove=*/true));
+
+  // Use unique MLIR content to avoid cache sharing with other tests.
+  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);
 
+  // Clean up the cache directory. Input/output files have remove=true but their
+  // destructors haven't run yet, so use remove_all to clean the directory.
   std::filesystem::remove_all(input.path.parent_path());
+
+  // Note: We don't clean up the temp tuning spec file here because IREE has
+  // process-wide caching that references this path. Deleting it would break
+  // subsequent tests. The temp directory will be cleaned up by the OS.
 }