Add support for tuning spec path via C API

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

Author: bangtianliu

README.md

@@ -177,72 +177,60 @@ 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.
+IREE tuning specs (transform dialect libraries) specify compiler code generation
+parameters like workgroup sizes, tile sizes, and MMA intrinsics for specific workloads.
+Pass tuning specs using the custom compiler flags shown 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
@@ -361,7 +349,7 @@ Alternatively, one may call the logging API directly as needed:
 
 | Environment Variable                     | Description
 | ---------------------------------------- | -----------
-| `FUSILLI_COMPILE_BACKEND_USE_CLI`        | Enables the use of the CLI tool to invoke compilation, otherwise uses CAPI
+| `FUSILLI_COMPILE_BACKEND_USE_CLI`        | Enables the use of the CLI tool to invoke compilation instead of C API (for debugging purposes; default: use C API)
 | `FUSILLI_EXTERNAL_IREE_COMPILE`          | Path to `iree-compile` binary
 | `FUSILLI_EXTERNAL_IREE_COMPILER_LIB`     | Path to the IREE compiler dynamic library
 | `FUSILLI_EXTERNAL_ROCM_AGENT_ENUMERATOR` | Path to `rocm_agent_enumerator` binary

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());
+}