[Cadence] Enabled x86 executor flow with numerical verification

Differential Revision: D60424030

Pull Request resolved: #4453

Author: zonglinpengmeta

backends/cadence/CMakeLists.txt

@@ -20,15 +20,64 @@ if(NOT EXECUTORCH_ROOT)
 endif()
 
 include(${EXECUTORCH_ROOT}/build/Utils.cmake)
+include(${EXECUTORCH_ROOT}/build/Codegen.cmake)
 
 # Let files say "include <executorch/path/to/header.h>".
 set(_common_include_directories ${EXECUTORCH_ROOT}/..)
 set(TARGET_DIR reference)
 
 if(EXECUTORCH_NNLIB_OPT)
 set(TARGET_DIR hifi)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_DIR}/third-party/nnlib)  
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_DIR}/third-party/nnlib)
 endif()
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Source root directory for executorch.
+if(NOT EXECUTORCH_ROOT)
+  set(EXECUTORCH_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../..)
+endif()
+
+if(NOT PYTHON_EXECUTABLE)
+  resolve_python_executable()
+endif()
+
+set(_common_compile_options -Wno-deprecated-declarations -fPIC)
+
+# Find prebuilt libraries. executorch package should contain portable_ops_lib,
+# etdump, bundled_program.
+find_package(executorch CONFIG REQUIRED)
+target_link_options_shared_lib(executorch)
+target_link_options_shared_lib(portable_ops_lib)
+
+target_include_directories(executorch INTERFACE ${_common_include_directories})
+
+find_package(
+  gflags REQUIRED PATHS ${CMAKE_CURRENT_BINARY_DIR}/../../third-party
+)
+
+add_executable(cadence_runner cadence_runner/cadence_runner.cpp)
+target_compile_options(executorch INTERFACE -DET_EVENT_TRACER_ENABLED)
 
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_DIR}/operators)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_DIR}/kernels)
+
+target_include_directories(
+  etdump INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/../../sdk/include
+                   ${EXECUTORCH_ROOT}/third-party/flatcc/include
+)
+
+target_include_directories(
+  cadence_runner PUBLIC ${ROOT_DIR}/.. ${CMAKE_BINARY_DIR}
+                                    ${_common_include_directories}
+)
+
+target_link_libraries(
+  cadence_runner
+  executorch
+  gflags
+  etdump
+  extension_data_loader
+  bundled_program
+  cadence_ops_lib
+  flatccrt
+)

backends/cadence/aot/export_example.py

@@ -7,17 +7,21 @@
 # Example script for exporting simple models to flatbuffer
 
 import logging
+import tempfile
 
 from executorch.backends.cadence.aot.ops_registrations import *  # noqa
-
 import os
 from typing import Any, Tuple
 
 from executorch.backends.cadence.aot.compiler import (
+    convert_pt2,
     export_to_cadence,
     export_to_edge,
     quantize_pt2,
 )
+from executorch.backends.cadence.aot.quantizer.quantizer import CadenceQuantizer
+from executorch.backends.cadence.runtime import runtime
+from executorch.backends.cadence.runtime.executor import BundledProgramManager
 from executorch.exir import ExecutorchProgramManager
 from torch import nn
 
@@ -44,23 +48,50 @@ def _save_pte_program(
         logging.error(f"Error while saving to {filename}: {e}")
 
 
+def _save_bpte_program(
+    buffer: bytes,
+    model_name: str,
+    output_dir: str = "",
+) -> None:
+    if model_name.endswith(".bpte"):
+        filename = model_name
+    else:
+        filename = os.path.join(output_dir, f"{model_name}.bpte")
+    try:
+        with open(filename, "wb") as f:
+            f.write(buffer)
+        logging.info(f"Saved exported program to {filename}")
+    except Exception as e:
+        logging.error(f"Error while saving to {output_dir}: {e}")
+
+
 def export_model(
     model: nn.Module,
     example_inputs: Tuple[Any, ...],
     file_name: str = "CadenceDemoModel",
 ):
+    # create work directory for outputs and model binary
+    working_dir = tempfile.mkdtemp(dir="/tmp")
+    logging.debug(f"Created work directory {working_dir}")
+
+    # convert the model (also called in quantize_pt2)
+    converted_model = convert_pt2(model, example_inputs, CadenceQuantizer())
+
+    # Get reference outputs from quantized_model
+    ref_outputs = converted_model(*example_inputs)
+
     # Quantize the model
     quantized_model = quantize_pt2(model, example_inputs)
 
-    # Get edge program
+    # Get edge program (also called in export_to_cadence)
     edge_prog_manager = export_to_edge(quantized_model, example_inputs)
 
     # Get edge program after Cadence specific passes
     cadence_prog_manager = export_to_cadence(quantized_model, example_inputs)
 
-    exec_prog = cadence_prog_manager.to_executorch()
+    exec_prog: ExecutorchProgramManager = cadence_prog_manager.to_executorch()
 
-    logging.info("Final exported graph:")
+    logging.info("Final exported graph:\n")
     exec_prog.exported_program().graph_module.graph.print_tabular()
 
     # Print some information to terminal
@@ -69,5 +100,28 @@ def export_model(
         cadence_prog_manager.exported_program().graph_module,
     )
 
-    # Save the program as (default name is CadenceDemoModel.pte)
-    _save_pte_program(exec_prog, file_name)
+    forward_test_data = BundledProgramManager.bundled_program_test_data_gen(
+        method="forward", inputs=example_inputs, expected_outputs=ref_outputs
+    )
+    bundled_program_manager = BundledProgramManager([forward_test_data])
+    buffer = bundled_program_manager._serialize(
+        exec_prog,
+        bundled_program_manager.get_method_test_suites(),
+        forward_test_data,
+    )
+    # Save the program as pte (default name is CadenceDemoModel.pte)
+    _save_pte_program(exec_prog, file_name, working_dir)
+    # Save the program as btpe (default name is CadenceDemoModel.bpte)
+    _save_bpte_program(buffer, file_name, working_dir)
+
+    logging.debug(
+        f"Executorch bundled program buffer saved to {file_name} is {len(buffer)} total bytes"
+    )
+
+    # TODO: move to test infra
+    runtime.run_and_compare(
+        executorch_prog=exec_prog,
+        inputs=example_inputs,
+        ref_outputs=ref_outputs,
+        working_dir=working_dir,
+    )

backends/cadence/build_cadence_runner.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Builds cadence_runner and prints its path.
+
+set -euo pipefail
+
+SCRIPT_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+readonly SCRIPT_DIR
+
+readonly EXECUTORCH_ROOT="${SCRIPT_DIR}/../.."
+
+# Allow overriding the number of build jobs. Default to 9.
+export CMAKE_BUILD_PARALLEL_LEVEL="${CMAKE_BUILD_PARALLEL_LEVEL:-9}"
+
+main() {
+  cd "${EXECUTORCH_ROOT}"
+
+  rm -rf cmake-out
+  cmake -DCMAKE_INSTALL_PREFIX=cmake-out \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DEXECUTORCH_BUILD_SDK=ON \
+    -DEXECUTORCH_ENABLE_EVENT_TRACER=ON \
+    -DPYTHON_EXECUTABLE=python3 \
+    -DEXECUTORCH_BUILD_EXTENSION_RUNNER_UTIL=ON \
+    -DEXECUTORCH_BUILD_HOST_TARGETS=ON \
+    -DEXECUTORCH_BUILD_EXECUTOR_RUNNER=OFF \
+    -DEXECUTORCH_BUILD_PTHREADPOOL=OFF \
+    -DEXECUTORCH_BUILD_CPUINFO=OFF \
+    -DEXECUTORCH_ENABLE_LOGGING=ON \
+    -Bcmake-out .
+  cmake --build cmake-out --target install --config Release
+
+  local example_dir=backends/cadence
+  local build_dir="cmake-out/${example_dir}"
+  local cmake_prefix_path="${PWD}/cmake-out/lib/cmake/ExecuTorch;${PWD}/cmake-out/third-party/gflags"
+  rm -rf ${build_dir}
+  cmake -DCMAKE_PREFIX_PATH="${cmake_prefix_path}" \
+    -DCMAKE_BUILD_TYPE=Release \
+    -B"${build_dir}" \
+    "${example_dir}"
+  cmake --build "${build_dir}" --config Release
+
+  local runner="${PWD}/${build_dir}/cadence_runner"
+  if [[ ! -f "${runner}" ]]; then
+    echo "ERROR: Failed to build ${build_dir}/cadence_runner" >&2
+    exit 1
+  else
+    echo "Built ${build_dir}/cadence_runner"
+  fi
+}
+
+main "$@"

backends/cadence/cadence_runner/TARGETS

@@ -0,0 +1,8 @@
+# Any targets that should be shared between fbcode and xplat must be defined in
+# targets.bzl. This file can contain fbcode-only targets.
+
+load(":targets.bzl", "define_common_targets")
+
+oncall("odai_jarvis")
+
+define_common_targets()