Consolidating executor runners in CMake - xnnpack (#11239)

### Summary
Continuing the process of consolidating the executor runners to top
level CMakeLists.txt file. Completing this process for the xnnpack
backend in the cmake build flow.

`Partially Fixes #<10819>` :
#10819.

### Test plan
Successfully ran the commands in the [building from
source](https://github.com/BujSet/executorch/blob/main/docs/source/using-executorch-building-from-source.md)
guide. Updated the github actions to not use the generic
`executor_runner` and remove the invocation for the backend-specific
`xnn_executor_runner`. Also ran the following formatinng and lint
checks:

```cmake-format -i backends/xnnpack/CMakeLists.txt```

```cmake-lint backends/xnnpack/CMakeLists.txt```

Includes updates to documentation and tutorials (flows from examples and
tutorials were verify to ensure build functionality).

Note: the buck flow side of things was unmodified, and support for that
flow remains for a future change.

Author: BujSet

.ci/scripts/test_model.sh

@@ -49,14 +49,24 @@ prepare_artifacts_upload() {
 }
 
 build_cmake_executor_runner() {
+  local backend_string_select="${1:-}"
   echo "Building executor_runner"
   rm -rf ${CMAKE_OUTPUT_DIR}
-  cmake -DCMAKE_BUILD_TYPE=Debug \
-      -DEXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON \
-      -DPYTHON_EXECUTABLE="$PYTHON_EXECUTABLE" \
-      -B${CMAKE_OUTPUT_DIR} .
-
-  cmake --build ${CMAKE_OUTPUT_DIR} -j4 --config Debug
+  mkdir ${CMAKE_OUTPUT_DIR}
+  if [[ "$backend_string_select" == "XNNPACK" ]]; then
+    echo "Backend $backend_string_select selected"
+    (cd ${CMAKE_OUTPUT_DIR} \
+      && cmake -DCMAKE_BUILD_TYPE=Release \
+        -DEXECUTORCH_BUILD_XNNPACK=ON \
+        -DPYTHON_EXECUTABLE="$PYTHON_EXECUTABLE" ..)
+    cmake --build ${CMAKE_OUTPUT_DIR} -j4
+  else
+    cmake -DCMAKE_BUILD_TYPE=Debug \
+        -DEXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON \
+        -DPYTHON_EXECUTABLE="$PYTHON_EXECUTABLE" \
+        -B${CMAKE_OUTPUT_DIR} .
+    cmake --build ${CMAKE_OUTPUT_DIR} -j4 --config Debug
+  fi
 }
 
 run_portable_executor_runner() {
@@ -111,19 +121,6 @@ test_model() {
   run_portable_executor_runner
 }
 
-build_cmake_xnn_executor_runner() {
-  echo "Building xnn_executor_runner"
-
-  (rm -rf ${CMAKE_OUTPUT_DIR} \
-    && mkdir ${CMAKE_OUTPUT_DIR} \
-    && cd ${CMAKE_OUTPUT_DIR} \
-    && retry cmake -DCMAKE_BUILD_TYPE=Release \
-      -DEXECUTORCH_BUILD_XNNPACK=ON \
-      -DPYTHON_EXECUTABLE="$PYTHON_EXECUTABLE" ..)
-
-  cmake --build ${CMAKE_OUTPUT_DIR} -j4
-}
-
 test_model_with_xnnpack() {
   WITH_QUANTIZATION=$1
   WITH_DELEGATION=$2
@@ -148,12 +145,11 @@ test_model_with_xnnpack() {
 
   # Run test model
   if [[ "${BUILD_TOOL}" == "buck2" ]]; then
+    # TODO eventually buck should also use consolidated executor runners
     buck2 run //examples/xnnpack:xnn_executor_runner -- --model_path "${OUTPUT_MODEL_PATH}"
   elif [[ "${BUILD_TOOL}" == "cmake" ]]; then
-    if [[ ! -f ${CMAKE_OUTPUT_DIR}/backends/xnnpack/xnn_executor_runner ]]; then
-      build_cmake_xnn_executor_runner
-    fi
-    ./${CMAKE_OUTPUT_DIR}/backends/xnnpack/xnn_executor_runner --model_path "${OUTPUT_MODEL_PATH}"
+    build_cmake_executor_runner "XNNPACK"
+    ./${CMAKE_OUTPUT_DIR}/executor_runner --model_path "${OUTPUT_MODEL_PATH}"
   else
     echo "Invalid build tool ${BUILD_TOOL}. Only buck2 and cmake are supported atm"
     exit 1

backends/xnnpack/CMakeLists.txt

@@ -61,7 +61,10 @@ foreach(fbs_file ${_xnnpack_schema__srcs})
 endforeach()
 
 if(WIN32)
-  set(MV_COMMAND powershell -Command "Move-Item -Path ${_xnnpack_flatbuffer__outputs} -Destination ${_xnnpack_schema__outputs}")
+  set(MV_COMMAND
+      powershell -Command
+      "Move-Item -Path ${_xnnpack_flatbuffer__outputs} -Destination ${_xnnpack_schema__outputs}"
+  )
 else()
   set(MV_COMMAND mv ${_xnnpack_flatbuffer__outputs} ${_xnnpack_schema__outputs})
 endif()
@@ -96,7 +99,8 @@ include(cmake/Dependencies.cmake)
 list(TRANSFORM _xnnpack_backend__srcs PREPEND "${EXECUTORCH_ROOT}/")
 add_library(xnnpack_backend ${_xnnpack_backend__srcs})
 target_link_libraries(
-  xnnpack_backend PUBLIC ${xnnpack_third_party} executorch_core xnnpack_schema extension_threadpool
+  xnnpack_backend PUBLIC ${xnnpack_third_party} executorch_core xnnpack_schema
+                         extension_threadpool
 )
 
 target_include_directories(
@@ -114,46 +118,8 @@ target_include_directories(
 target_compile_options(xnnpack_backend PUBLIC ${_common_compile_options})
 target_link_options_shared_lib(xnnpack_backend)
 
-if(EXECUTORCH_BUILD_KERNELS_OPTIMIZED)
-  list(APPEND xnn_executor_runner_libs optimized_native_cpu_ops_lib)
-else()
-  list(APPEND xnn_executor_runner_libs portable_ops_lib)
-endif()
-
-if(EXECUTORCH_BUILD_KERNELS_CUSTOM)
-  list(APPEND xnn_executor_runner_libs $<LINK_LIBRARY:WHOLE_ARCHIVE,custom_ops>)
-endif()
-
-if(EXECUTORCH_BUILD_KERNELS_QUANTIZED)
-  list(APPEND xnn_executor_runner_libs quantized_ops_lib)
-endif()
-
-list(APPEND xnn_executor_runner_libs xnnpack_backend executorch)
-
-# ios can only build library but not binary
-if(NOT CMAKE_TOOLCHAIN_FILE MATCHES ".*(iOS|ios\.toolchain)\.cmake$")
-  #
-  # xnn_executor_runner: Like executor_runner but with XNNPACK, the binary will
-  # be at ${CMAKE_BINARY_DIR}/backends/xnnpack
-  #
-  list(TRANSFORM _xnn_executor_runner__srcs PREPEND "${EXECUTORCH_ROOT}/")
-  add_executable(xnn_executor_runner ${_xnn_executor_runner__srcs})
-
-  if(EXECUTORCH_ENABLE_EVENT_TRACER)
-    list(APPEND xnn_executor_runner_libs etdump)
-  endif()
-
-  target_link_libraries(xnn_executor_runner gflags ${xnn_executor_runner_libs})
-  target_compile_options(xnn_executor_runner PUBLIC ${_common_compile_options})
-  if(EXECUTORCH_BUILD_PTHREADPOOL)
-    target_link_libraries(xnn_executor_runner extension_threadpool pthreadpool)
-    target_compile_definitions(xnn_executor_runner PRIVATE ET_USE_THREADPOOL)
-  endif()
-endif()
-
 install(
   TARGETS xnnpack_backend
-  DESTINATION lib
   INCLUDES
   DESTINATION ${_common_include_directories}
 )

backends/xnnpack/README.md

@@ -92,7 +92,7 @@ After lowering to the XNNPACK Program, we can then prepare it for executorch and
 
 
 ### Running the XNNPACK Model with CMake
-After exporting the XNNPACK Delegated model, we can now try running it with example inputs using CMake. We can build and use the xnn_executor_runner, which is a sample wrapper for the ExecuTorch Runtime and XNNPACK Backend. We first begin by configuring the CMake build like such:
+After exporting the XNNPACK Delegated model, we can now try running it with example inputs using CMake. We can build and use the executor_runner, which is a sample wrapper for the ExecuTorch Runtime. The XNNPACK Backend is enabled via the compilation flag `-DEXECUTORCH_BUILD_XNNPACK=ON`. We first begin by configuring the CMake build like such:
 ```bash
 # cd to the root of executorch repo
 cd executorch
@@ -119,9 +119,9 @@ Then you can build the runtime componenets with
 cmake --build cmake-out -j9 --target install --config Release
 ```
 
-Now you should be able to find the executable built at `./cmake-out/backends/xnnpack/xnn_executor_runner` you can run the executable with the model you generated as such
+Now you should be able to find the executable built at `./cmake-out/executor_runner` you can run the executable with the model you generated as such
 ```bash
-./cmake-out/backends/xnnpack/xnn_executor_runner --model_path=./mv2_xnnpack_fp32.pte
+./cmake-out/executor_runner --model_path=./mv2_xnnpack_fp32.pte
 ```
 
 ## Help & Improvements

docs/source/backend-delegates-xnnpack-reference.md

@@ -70,7 +70,7 @@ Since weight packing creates an extra copy of the weights inside XNNPACK, We fre
 When executing the XNNPACK subgraphs, we prepare the tensor inputs and outputs and feed them to the XNNPACK runtime graph. After executing the runtime graph, the output pointers are filled with the computed tensors.
 
 #### **Profiling**
-We have enabled basic profiling for the XNNPACK delegate that can be enabled with the compiler flag `-DEXECUTORCH_ENABLE_EVENT_TRACER` (add `-DENABLE_XNNPACK_PROFILING` for additional details). With ExecuTorch's Developer Tools integration, you can also now use the Developer Tools to profile the model. You can follow the steps in [Using the ExecuTorch Developer Tools to Profile a Model](https://pytorch.org/executorch/main/tutorials/devtools-integration-tutorial) on how to profile ExecuTorch models and use Developer Tools' Inspector API to view XNNPACK's internal profiling information. An example implementation is available in the `xnn_executor_runner` (see [tutorial here](tutorial-xnnpack-delegate-lowering.md#profiling)).
+We have enabled basic profiling for the XNNPACK delegate that can be enabled with the compiler flag `-DEXECUTORCH_ENABLE_EVENT_TRACER` (add `-DENABLE_XNNPACK_PROFILING` for additional details). With ExecuTorch's Developer Tools integration, you can also now use the Developer Tools to profile the model. You can follow the steps in [Using the ExecuTorch Developer Tools to Profile a Model](https://pytorch.org/executorch/main/tutorials/devtools-integration-tutorial) on how to profile ExecuTorch models and use Developer Tools' Inspector API to view XNNPACK's internal profiling information. An example implementation is available in the `executor_runner` (see [tutorial here](tutorial-xnnpack-delegate-lowering.md#profiling)).
 
 
 [comment]: <> (TODO: Refactor quantizer to a more official quantization doc)

docs/source/tutorial-xnnpack-delegate-lowering.md

@@ -141,7 +141,7 @@ Note in the example above,
 The generated model file will be named `[model_name]_xnnpack_[qs8/fp32].pte` depending on the arguments supplied.
 
 ## Running the XNNPACK Model with CMake
-After exporting the XNNPACK Delegated model, we can now try running it with example inputs using CMake. We can build and use the xnn_executor_runner, which is a sample wrapper for the ExecuTorch Runtime and XNNPACK Backend. We first begin by configuring the CMake build like such:
+After exporting the XNNPACK Delegated model, we can now try running it with example inputs using CMake. We can build and use the executor_runner, which is a sample wrapper for the ExecuTorch Runtime. The XNNPACK Backend is enabled via the compilation flag `-DEXECUTORCH_BUILD_XNNPACK=ON`. We first begin by configuring the CMake build like such:
 ```bash
 # cd to the root of executorch repo
 cd executorch
@@ -168,15 +168,15 @@ Then you can build the runtime componenets with
 cmake --build cmake-out -j9 --target install --config Release
 ```
 
-Now you should be able to find the executable built at `./cmake-out/backends/xnnpack/xnn_executor_runner` you can run the executable with the model you generated as such
+Now you should be able to find the executable built at `./cmake-out/executor_runner` you can run the executable with the model you generated as such
 ```bash
-./cmake-out/backends/xnnpack/xnn_executor_runner --model_path=./mv2_xnnpack_fp32.pte
+./cmake-out/executor_runner --model_path=./mv2_xnnpack_fp32.pte
 # or to run the quantized variant
-./cmake-out/backends/xnnpack/xnn_executor_runner --model_path=./mv2_xnnpack_q8.pte
+./cmake-out/executor_runner --model_path=./mv2_xnnpack_q8.pte
 ```
 
 ## Building and Linking with the XNNPACK Backend
 You can build the XNNPACK backend [CMake target](https://github.com/pytorch/executorch/blob/main/backends/xnnpack/CMakeLists.txt#L83), and link it with your application binary such as an Android or iOS application. For more information on this you may take a look at this [resource](using-executorch-android.md) next.
 
 ## Profiling
-To enable profiling in the `xnn_executor_runner` pass the flags `-DEXECUTORCH_ENABLE_EVENT_TRACER=ON` and `-DEXECUTORCH_BUILD_DEVTOOLS=ON` to the build command (add `-DENABLE_XNNPACK_PROFILING=ON` for additional details). This will enable ETDump generation when running the inference and enables command line flags for profiling (see `xnn_executor_runner --help` for details).
+To enable profiling in the `executor_runner` pass the flags `-DEXECUTORCH_ENABLE_EVENT_TRACER=ON` and `-DEXECUTORCH_BUILD_DEVTOOLS=ON` to the build command (add `-DENABLE_XNNPACK_PROFILING=ON` for additional details). This will enable ETDump generation when running the inference and enables command line flags for profiling (see `executor_runner --help` for details).

examples/xnnpack/README.md

@@ -24,7 +24,7 @@ The following command will produce a floating-point XNNPACK delegated model `mv2
 python3 -m examples.xnnpack.aot_compiler --model_name="mv2" --delegate
 ```
 
-Once we have the model binary (pte) file, then let's run it with ExecuTorch runtime using the `xnn_executor_runner`. With cmake, you first configure your cmake with the following:
+Once we have the model binary (pte) file, then let's run it with ExecuTorch runtime using the `executor_runner`. With cmake, you first configure your cmake with the following:
 
 ```bash
 # cd to the root of executorch repo
@@ -56,7 +56,7 @@ cmake --build cmake-out -j9 --target install --config Release
 Now finally you should be able to run this model with the following command
 
 ```bash
-./cmake-out/backends/xnnpack/xnn_executor_runner --model_path ./mv2_xnnpack_fp32.pte
+./cmake-out/executor_runner --model_path ./mv2_xnnpack_fp32.pte
 ```
 
 ## Quantization
@@ -80,7 +80,7 @@ python3 -m examples.xnnpack.quantization.example --help
 ```
 
 ## Running the XNNPACK Model with CMake
-After exporting the XNNPACK Delegated model, we can now try running it with example inputs using CMake. We can build and use the xnn_executor_runner, which is a sample wrapper for the ExecuTorch Runtime and XNNPACK Backend. We first begin by configuring the CMake build like such:
+After exporting the XNNPACK Delegated model, we can now try running it with example inputs using CMake. We can build and use the executor_runner, which is a sample wrapper for the ExecuTorch Runtime. The XNNPACK Backend is enabled via the compilation flag `-DEXECUTORCH_BUILD_XNNPACK=ON`. We first begin by configuring the CMake build like such:
 ```bash
 # cd to the root of executorch repo
 cd executorch
@@ -107,9 +107,9 @@ Then you can build the runtime componenets with
 cmake --build cmake-out -j9 --target install --config Release
 ```
 
-Now you should be able to find the executable built at `./cmake-out/backends/xnnpack/xnn_executor_runner` you can run the executable with the model you generated as such
+Now you should be able to find the executable built at `./cmake-out/executor_runner` you can run the executable with the model you generated as such
 ```bash
-./cmake-out/backends/xnnpack/xnn_executor_runner --model_path=./mv2_quantized.pte
+./cmake-out/executor_runner --model_path=./mv2_quantized.pte
 ```
 
 ## Delegating a Quantized Model