Add support for tuning spec path via C API

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

Author: bangtianliu

README.md

@@ -177,72 +177,61 @@ The wrapper automatically:
 
 #### Custom Compiler Flags
 
-You can pass custom IREE compiler flags using the `FUSILLI_EXTRA_COMPILER_FLAGS`
-environment variable or the `--Xiree-compile` flag with the Python benchmark
-wrapper.
+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)
 
-**Using the C++ benchmark driver with environment variable:**
+**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
+  matmul -M 8192 -N 2048 -K 4096 --transA --a_type bf16 --b_type bf16 --out_type bf16
 ```
 
-**Using the Python benchmark wrapper:**
+Python wrapper:
 ```shell
 python benchmarks/run_benchmark.py \
   --Xiree-compile="--iree-opt-level=O3" \
-  -o results.csv \
-  -f commands.txt
+  -f commands.txt -o results.csv
 ```
 
-**Passing multiple compiler flags:**
+**Multiple flags:**
 
-Using environment variable:
+C++ driver (space-separated in one string):
 ```shell
 FUSILLI_EXTRA_COMPILER_FLAGS="--iree-opt-level=O3 --iree-hal-dump-executable-files-to=/tmp/dump" \
   build/bin/benchmarks/fusilli_benchmark_driver ...
 ```
 
-Using Python wrapper:
+Python wrapper (repeat `--Xiree-compile`):
 ```shell
 python benchmarks/run_benchmark.py \
   --Xiree-compile="--iree-opt-level=O3" \
   --Xiree-compile="--iree-hal-dump-executable-files-to=/tmp/dump" \
   -f commands.txt -o results.csv
 ```
 
-> [!NOTE]
-> If an extra compiler flag is exposed via CLI but not the C API, please select
-> the CLI backend (set `FUSILLI_COMPILE_BACKEND_USE_CLI=1`). Currently,
-> `--iree-codegen-tuning-spec-path` requires this since it is not exposed
-> through the C API. This limitation is being addressed and will be lifted
-> shortly.
-
 #### Tuning Specs
 
 IREE tuning specs (transform dialect libraries) specify optimal compiler code
 generation parameters such as workgroup sizes, tile sizes, MMA intrinsics, and
 shared memory allocation suited for specific workloads. You can pass tuning
 specs using the custom compiler flags feature described above.
 
-**Example with C++ benchmark driver:**
+C++ driver:
 ```shell
-FUSILLI_COMPILE_BACKEND_USE_CLI=1 \
 FUSILLI_EXTRA_COMPILER_FLAGS="--iree-codegen-tuning-spec-path=/path/to/tuning_spec.mlir" \
   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
+  matmul -M 8192 -N 2048 -K 4096 --transA --a_type bf16 --b_type bf16 --out_type bf16
 ```
 
-**Example with Python benchmark wrapper:**
+Python wrapper:
 ```shell
-FUSILLI_COMPILE_BACKEND_USE_CLI=1 \
-  python benchmarks/run_benchmark.py \
+python benchmarks/run_benchmark.py \
   --Xiree-compile="--iree-codegen-tuning-spec-path=/path/to/tuning_spec.mlir" \
-  -o results.csv \
-  -f commands.txt
+  -f commands.txt -o results.csv
 ```
 
 ### Sanitizers

benchmarks/test_benchmark_runner.sh

@@ -6,10 +6,6 @@ set -x
 BENCHMARK_RUNNER="$1"
 BENCHMARK_DRIVER="$2"
 
-# Use CLI backend for tests (--iree-codegen-tuning-spec-path not available via C API)
-# TODO(iree-org/iree#23314): Remove this when tuning spec path support is added to C API
-export FUSILLI_COMPILE_BACKEND_USE_CLI=1
-
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 TEST_COMMANDS="${SCRIPT_DIR}/test_commands.txt"
 OUTPUT_CSV=$(mktemp)

tests/test_compile_session.cpp

@@ -519,3 +519,74 @@ TEST_CASE("CompileSession::getArgs", "[CompileSession]") {
   }
   std::filesystem::remove_all(input.path.parent_path());
 }
+
+TEST_CASE("CompileSession::addFlag with tuning spec path",
+          "[CompileSession][tuning_spec]") {
+  // Verify tuning spec path flag is accepted by C API.
+  FUSILLI_REQUIRE_ASSIGN(auto *context, CompileContext::create());
+  REQUIRE(context != nullptr);
+  FUSILLI_REQUIRE_ASSIGN(Handle handle, Handle::create(kDefaultBackend));
+  FUSILLI_REQUIRE_ASSIGN(auto session, context->createSession(handle));
+
+  std::string tuningSpecPath = "/tmp/test_tuning_spec.mlir";
+
+  auto result =
+      session.addFlag("--iree-codegen-tuning-spec-path=" + tuningSpecPath);
+  FUSILLI_REQUIRE_OK(result);
+
+  // Verify the flag was stored.
+  const auto &args = session.getArgs();
+  bool hasTuningSpecFlag = false;
+  for (const auto &arg : args) {
+    if (arg.find("--iree-codegen-tuning-spec-path") != std::string::npos) {
+      hasTuningSpecFlag = true;
+      break;
+    }
+  }
+  REQUIRE(hasTuningSpecFlag);
+}
+
+TEST_CASE("CompileSession::compile with tuning spec",
+          "[CompileSession][integration][tuning_spec]") {
+  // End-to-end compilation with tuning spec via C API.
+  FUSILLI_REQUIRE_ASSIGN(auto *context, CompileContext::create());
+  REQUIRE(context != nullptr);
+  FUSILLI_REQUIRE_ASSIGN(Handle handle, Handle::create(kDefaultBackend));
+  FUSILLI_REQUIRE_ASSIGN(auto 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"(
+// Minimal no-op tuning spec for testing.
+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()));
+  FUSILLI_REQUIRE_ASSIGN(
+      CacheFile input,
+      CacheFile::create(kGraphName, "input_with_spec.mlir", /*remove=*/true));
+  FUSILLI_REQUIRE_ASSIGN(
+      CacheFile output,
+      CacheFile::create(kGraphName, "output_with_spec.vmfb", /*remove=*/true));
+
+  std::string mlirContent = getSimpleMLIRModule();
+  FUSILLI_REQUIRE_OK(input.write(mlirContent));
+
+  auto compileResult =
+      session.compile(input.path.string(), output.path.string());
+  FUSILLI_REQUIRE_OK(compileResult);
+  REQUIRE(std::filesystem::exists(output.path));
+  REQUIRE(std::filesystem::file_size(output.path) > 0);
+
+  std::filesystem::remove_all(input.path.parent_path());
+}