@@ -5,12 +5,15 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-# Generates the ExecuTorch ESP-IDF component and a kernel bundle for the smoke
-# model, builds the idf_component_smoke consumer for ESP32-C6 with that bundle,
-# plus the Cadence kernels, and for ESP32-S3 with one the build generates
-# itself, and runs the ESP32-S3 build on the emulator. Also checks that stale or
-# mismatched bundles fail at configure time, and that an app declaring nothing
-# links to the same size as one without the component.
+# Generates the ExecuTorch ESP-IDF component and runs the idf_component_smoke
+# consumer on the emulator with three models: the portable-kernel smoke model, a
+# mul on the esp_nn:: op library and an ESP-NN delegate program. An ESP32-S3
+# build runs all three with a kernel bundle the build makes itself; an ESP32-C6
+# build runs the first two, with the Cadence kernels too, and must not link the
+# delegate; two more ESP32-S3 builds run the delegate alone, from a bundle with
+# no kernel libraries and from executorch_add_backend with no bundle. Also
+# checks that stale or mismatched bundles fail at configure time, and that an
+# app declaring nothing links to the same size as one without the component.
 
 set -euo pipefail
 
@@ -39,16 +42,38 @@ bash examples/espressif/setup.sh --minimal --targets=esp32s3,esp32c6 2>&1 \
 # shellcheck source=/dev/null
 source "${ESPRESSIF_TOOLS_DIR}/setup_path.sh"
 
-python examples/espressif/export_smoke_model.py \
-    --output "${build_dir}/smoke.bpte" --pte-output "${build_dir}/smoke.pte" \
+python examples/espressif/export_smoke_model.py --output "${build_dir}/smoke.bpte" \
     2>&1 | tee "${build_dir}/export.log"
+python examples/espressif/idf_component_smoke/export_op_library_model.py \
+    --output "${build_dir}/mul.bpte" 2>&1 | tee -a "${build_dir}/export.log"
+python examples/espressif/export_espnn_test_programs.py --output-dir "${build_dir}/espnn" \
+    --only conv-act-pool-linear 2>&1 | tee -a "${build_dir}/export.log"
+cp "${build_dir}/espnn/conv-act-pool-linear.bpte" "${build_dir}/delegate.bpte"
+split=examples/espressif/idf_component_smoke/split_bundled_program.py
+python "${split}" "${build_dir}/smoke.bpte" --atol 0 --rtol 0
+# The tolerance test_mul.py uses.
+python "${split}" "${build_dir}/mul.bpte" --atol 0 --rtol 1.2e-7
+read -r atol rtol < <(python -c '
+import json, sys
+(entry,) = json.load(open(sys.argv[1]))
+print(entry["atol"], entry["rtol"])
+' "${build_dir}/espnn/manifest.json")
+python "${split}" "${build_dir}/delegate.bpte" --atol "${atol}" --rtol "${rtol}"
+cpu_models="${build_dir}/smoke.pte;${build_dir}/mul.pte"
+models="${cpu_models};${build_dir}/delegate.pte"
 
 component_dir="${build_dir}/components/executorch"
 kernels_dir="${build_dir}/smoke_kernels"
 bash examples/espressif/build_idf_component.sh --out "${component_dir}" \
     2>&1 | tee "${build_dir}/generate.log"
-python "${component_dir}/tools/gen_kernels.py" --pte "${build_dir}/smoke.pte" \
-    --out "${kernels_dir}" 2>&1 | tee "${build_dir}/gen_kernels.log"
+gen_kernels() {
+    local out=$1
+    shift
+    python "${component_dir}/tools/gen_kernels.py" "$@" --out "${out}" \
+        2>&1 | tee -a "${build_dir}/gen_kernels.log"
+}
+gen_kernels "${kernels_dir}" --pte "${build_dir}/smoke.pte" --pte "${build_dir}/mul.pte" \
+    --pte "${build_dir}/delegate.pte"
 # The ESP32-C6 build also registers the ops of a Cadence-quantized streaming
 # wake word model, so CI compiles and links the Cadence generic kernels.
 wakeword_ops=aten::_softmax.out,aten::_to_copy.out,aten::cat.out,aten::copy_
@@ -58,9 +83,17 @@ wakeword_ops+=,cadence::dequantize_per_tensor.out,cadence::quantize_per_tensor.o
 wakeword_ops+=,cadence::quantized_conv2d_nhwc.per_tensor_out
 wakeword_ops+=,cadence::quantized_fully_connected.per_tensor_out
 wakeword_ops+=,cadence::quantized_relu.per_tensor_out
-python "${component_dir}/tools/gen_kernels.py" --pte "${build_dir}/smoke.pte" \
-    --ops "${wakeword_ops}" --out "${build_dir}/wakeword_kernels" \
-    2>&1 | tee -a "${build_dir}/gen_kernels.log"
+gen_kernels "${build_dir}/cpu_kernels" --pte "${build_dir}/smoke.pte" \
+    --pte "${build_dir}/mul.pte" --ops "${wakeword_ops}"
+gen_kernels "${build_dir}/delegate_kernels" --pte "${build_dir}/delegate.pte"
+python - "${build_dir}/delegate_kernels/kernels.json" <<'PY'
+import json
+import sys
+
+libraries = json.load(open(sys.argv[1]))["libraries"]
+if libraries:
+    sys.exit(f"FAIL: the delegate-only bundle has kernel libraries {sorted(libraries)}")
+PY
 
 project=examples/espressif/idf_component_smoke
 
@@ -94,7 +127,8 @@ mkdir -p "${build_dir}/stale"
 cp "${build_dir}/smoke.pte" "${build_dir}/stale/smoke.pte"
 printf '\0' >> "${build_dir}/stale/smoke.pte"
 expect_configure_error stale-model "smoke.pte: changed since the bundle was made" \
-    -DET_SMOKE_PTE="${build_dir}/stale/smoke.pte" -DET_SMOKE_KERNELS="${kernels_dir}"
+    -DET_SMOKE_MODELS="${build_dir}/stale/smoke.pte;${build_dir}/mul.pte;${build_dir}/delegate.pte" \
+    -DET_SMOKE_KERNELS="${kernels_dir}"
 
 rm -rf "${build_dir}/mismatch_kernels"
 cp -r "${kernels_dir}" "${build_dir}/mismatch_kernels"
@@ -107,7 +141,7 @@ bundle["component_version"] = "0.0.0"
 json.dump(bundle, open(sys.argv[1], "w"))
 PY
 expect_configure_error version-mismatch component_version \
-    -DET_SMOKE_PTE="${build_dir}/smoke.pte" \
+    -DET_SMOKE_MODELS="${models}" \
     -DET_SMOKE_KERNELS="${build_dir}/mismatch_kernels"
 
 # A bundle made by a component of the same version from another commit, as two
@@ -123,23 +157,23 @@ bundle["component_commit"] = "0" * 40
 json.dump(bundle, open(sys.argv[1], "w"))
 PY
 expect_configure_error commit-mismatch component_commit \
-    -DET_SMOKE_PTE="${build_dir}/smoke.pte" \
+    -DET_SMOKE_MODELS="${models}" \
     -DET_SMOKE_KERNELS="${build_dir}/mismatch_kernels"
 
 # Without an ExecuTorch Python to generate one, a missing bundle is an error.
 python -m venv --without-pip --clear "${build_dir}/bare_python"
 EXECUTORCH_PYTHON="${build_dir}/bare_python/bin/python" expect_configure_error \
-    no-bundle "cannot import executorch" -DET_SMOKE_PTE="${build_dir}/smoke.pte"
+    no-bundle "cannot import executorch" -DET_SMOKE_MODELS="${models}"
 expect_configure_error relative-python "must be the absolute path" \
-    -DET_SMOKE_PTE="${build_dir}/smoke.pte" -DEXECUTORCH_PYTHON=python
+    -DET_SMOKE_MODELS="${models}" -DEXECUTORCH_PYTHON=python
 
 # A kernel registry smaller than the bundle; the emulator run below uses one
 # larger than it.
 printf 'CONFIG_ET_MAX_KERNEL_NUM=1\n' > "${build_dir}/small_registry.defaults"
 printf 'CONFIG_ET_MAX_KERNEL_NUM=64\n' > "${build_dir}/large_registry.defaults"
 expect_configure_error small-registry "CONFIG_ET_MAX_KERNEL_NUM=1 is below" \
     "-DSDKCONFIG_DEFAULTS=sdkconfig.defaults;${build_dir}/small_registry.defaults" \
-    -DET_SMOKE_PTE="${build_dir}/smoke.pte" -DET_SMOKE_KERNELS="${kernels_dir}"
+    -DET_SMOKE_MODELS="${models}" -DET_SMOKE_KERNELS="${kernels_dir}"
 
 # An app that declares nothing must not grow because the component is in the
 # build. The baseline swaps the component for an empty one of the same name.
@@ -170,34 +204,80 @@ PY
 printf 'CONFIG_LIBC_NEWLIB=y\nCONFIG_LIBC_NEWLIB_NANO_FORMAT=y\n' > "${build_dir}/nano.defaults"
 consumer nano esp32s3 -DET_COMPONENT_DIR="${component_dir}" \
     "-DSDKCONFIG_DEFAULTS=sdkconfig.defaults;${build_dir}/nano.defaults" \
-    -DET_SMOKE_PTE="${build_dir}/smoke.pte" -DET_SMOKE_KERNELS="${kernels_dir}" reconfigure
+    -DET_SMOKE_MODELS="${models}" -DET_SMOKE_KERNELS="${kernels_dir}" reconfigure
 if ! tr -s ' \n' '  ' < "${build_dir}/firmware-nano.log" \
     | grep -qF "ExecuTorch logging is DISABLED"; then
     echo "FAIL: no nano printf warning; see ${build_dir}/firmware-nano.log" >&2
     exit 1
 fi
 
-consumer smoke-esp32c6 esp32c6 -DET_COMPONENT_DIR="${component_dir}" \
-    -DET_SMOKE_PTE="${build_dir}/smoke.pte" -DET_SMOKE_KERNELS="${build_dir}/wakeword_kernels" build
+# Runs a build on the emulator and checks its output: build name, chip, then
+# the per-model markers.
+run_firmware() {
+    local name=$1 chip=$2
+    shift 2
+    local firmware_dir="${build_dir}/firmware-${name}"
+    IDF_TARGET="${chip}" idf.py -C "${project}" -B "${firmware_dir}" merge-bin \
+        > "${build_dir}/merge-${name}.log" 2>&1
+    timeout 130s esp-emu --chip "${chip}" \
+        --firmware "${firmware_dir}/merged-binary.bin" \
+        --elf "${firmware_dir}/et_component_smoke.elf" \
+        --net user --timeout 120s --exit-on 'Program complete.' \
+        2>&1 | tee "${build_dir}/emulator-${name}.log"
+    for marker in "$@" "ET_COMPONENT_SMOKE: PASS" "Program complete."; do
+        if ! grep -qF "${marker}" "${build_dir}/emulator-${name}.log"; then
+            echo "FAIL: ${name} printed no '${marker}'; see emulator-${name}.log" >&2
+            exit 1
+        fi
+    done
+    echo "OK: ${name} passed on the ${chip} emulator"
+}
+
 # No bundle declared: the build makes one with its own Python, which has
 # executorch here, and it must match the one gen_kernels.py made above.
-consumer smoke-esp32s3 esp32s3 -DET_COMPONENT_DIR="${component_dir}" \
+consumer all-esp32s3 esp32s3 -DET_COMPONENT_DIR="${component_dir}" \
     "-DSDKCONFIG_DEFAULTS=sdkconfig.defaults;${build_dir}/large_registry.defaults" \
-    -DET_SMOKE_PTE="${build_dir}/smoke.pte" build
-diff -r "${build_dir}/firmware-smoke-esp32s3/executorch_kernels" "${kernels_dir}"
-
-firmware_dir="${build_dir}/firmware-smoke-esp32s3"
-idf.py -C "${project}" -B "${firmware_dir}" merge-bin \
-    2>&1 | tee "${build_dir}/firmware-merge.log"
-timeout 130s esp-emu --chip esp32s3 \
-    --firmware "${firmware_dir}/merged-binary.bin" \
-    --elf "${firmware_dir}/et_component_smoke.elf" \
-    --net user --timeout 120s --exit-on 'Program complete.' \
-    2>&1 | tee "${build_dir}/emulator.log"
-for marker in "ET_COMPONENT_SMOKE: PASS" "Program complete."; do
-    if ! grep -qF "${marker}" "${build_dir}/emulator.log"; then
-        echo "FAIL: missing '${marker}'; see ${build_dir}/emulator.log" >&2
-        exit 1
-    fi
-done
-echo "PASS: generated ESP-IDF component ran the smoke model on the ESP32-S3 emulator."
+    -DET_SMOKE_MODELS="${models}" build
+diff -r "${build_dir}/firmware-all-esp32s3/executorch_kernels" "${kernels_dir}"
+run_firmware all-esp32s3 esp32s3 "smoke: PASS" "mul: PASS" "delegate: PASS"
+
+# A project may provide esp-nn as its own component instead of the managed one.
+local_project="${build_dir}/local-esp-nn"
+rm -rf "${local_project}"
+mkdir -p "${local_project}/components"
+cp -r "${project}/CMakeLists.txt" "${project}/main" "${project}/sdkconfig.defaults" \
+    "${local_project}/"
+cp -r "${project}/managed_components/espressif__esp-nn" "${local_project}/components/esp-nn"
+project="${local_project}" consumer local-esp-nn esp32s3 -DET_COMPONENT_DIR="${component_dir}" \
+    -DET_SMOKE_MODELS="${build_dir}/delegate.pte" \
+    -DET_SMOKE_KERNELS="${build_dir}/delegate_kernels" reconfigure
+echo "OK: a project with its own components/esp-nn configures"
+
+consumer cpu-esp32c6 esp32c6 -DET_COMPONENT_DIR="${component_dir}" \
+    -DET_SMOKE_MODELS="${cpu_models}" -DET_SMOKE_KERNELS="${build_dir}/cpu_kernels" build
+# The esp_nn:: op library must not pull in the delegate.
+if riscv32-esp-elf-nm -C "${build_dir}/firmware-cpu-esp32c6/et_component_smoke.elf" \
+    | grep -q EspNNBackend; then
+    echo "FAIL: cpu-esp32c6 links EspNNBackend, which none of its models uses" >&2
+    exit 1
+fi
+run_firmware cpu-esp32c6 esp32c6 "smoke: PASS" "mul: PASS"
+
+consumer delegate-esp32s3 esp32s3 -DET_COMPONENT_DIR="${component_dir}" \
+    -DET_SMOKE_MODELS="${build_dir}/delegate.pte" \
+    -DET_SMOKE_KERNELS="${build_dir}/delegate_kernels" build
+run_firmware delegate-esp32s3 esp32s3 "delegate: PASS"
+
+# Models not known at build time: only the delegate is declared.
+consumer backend-esp32s3 esp32s3 -DET_COMPONENT_DIR="${component_dir}" \
+    -DET_SMOKE_MODELS="${build_dir}/delegate.pte" -DET_SMOKE_BACKENDS=EspNNBackend build
+run_firmware backend-esp32s3 esp32s3 "delegate: PASS"
+# Without a bundle nothing registers kernels, so the registry reserves no room.
+registry=$(xtensa-esp32s3-elf-nm -S -C "${build_dir}/firmware-backend-esp32s3/et_component_smoke.elf" \
+    | awk '/registered_kernels_data/ {print $2}')
+if (( 16#${registry:-0} > 64 )); then
+    echo "FAIL: backend-esp32s3 reserves $((16#${registry})) B for kernels it never registers" >&2
+    exit 1
+fi
+
+echo "PASS: generated ESP-IDF component ran every build on the emulator."
@@ -21,7 +21,8 @@ component from sources in this repository:
 
 The output is a registry-shaped component (`idf_component.yml`,
 `CMakeLists.txt`, `Kconfig`, `VERSION`) containing the runtime, the
-portable, quantized and Cadence generic kernel libraries, the shared
+portable, quantized, Cadence generic and `esp_nn::` kernel libraries,
+the ESP-NN delegate, the shared
 ESP-IDF PAL from `platform/esp_pal.cpp` (ESP_LOG + `esp_timer` timing),
 and a C inference API (`et_model.h`, flash-XIP model bytes with
 internal/PSRAM arena placement). Only the kernels a project's models
 
@@ -15,8 +15,9 @@
 #
 # Derived from examples/arduino/build_arduino_library.sh with an ESP-IDF
 # output layout and the shared ESP-IDF PAL. The component vendors every
-# kernel source of its kernel libraries (portable, quantized and the
-# Cadence backend's generic kernels) but registers none of them: a
+# kernel source of its kernel libraries (portable, quantized, the Cadence
+# backend's generic kernels and the esp_nn:: op library) and the ESP-NN
+# delegate, but registers none of them: a
 # project's kernel bundle, made by the component's tools/gen_kernels.py
 # from its models, selects the kernels at build time.
 #
@@ -204,15 +205,24 @@ copy_srcs() { # ET_ROOT-relative paths on stdin; $1 = list file to append to
 
 : > "$SCRATCH/core_srcs.txt"
 : > "$SCRATCH/kernel_srcs.txt"
+: > "$SCRATCH/espnn_srcs.txt"
 bzl_list EXECUTORCH_CORE_SRCS | copy_srcs "$SCRATCH/core_srcs.txt"
 # register_prim_ops.cpp is compiled by the build, with the bundle's prim
 # selection, only when a project has a kernel bundle.
 bzl_list EXECUTORCH_SRCS | grep -v '/register_prim_ops\.cpp$' \
   | copy_srcs "$SCRATCH/kernel_srcs.txt"
 echo "kernels/prim_ops/register_prim_ops.cpp" | copy_srcs "$SCRATCH/prim_src.txt"
 ( cd "$ET_ROOT" && find kernels/portable/cpu kernels/quantized/cpu \
-    backends/cadence/generic -name '*.cpp' -not -path '*/test*/*' | sort ) \
+    backends/cadence/generic backends/espressif/ops -name '*.cpp' \
+    -not -path '*/test*/*' | sort ) \
   | copy_srcs "$SCRATCH/kernel_srcs.txt"
+# The ESP-NN delegate runtime, an ESP-IDF component of its own in-tree.
+ESPNN_RUNTIME="$ET_ROOT/backends/espressif/espnn_runtime"
+mkdir -p "$OUT_DIR/src/espnn"
+for f in "$ESPNN_RUNTIME"/src/*.cpp; do
+  cp "$f" "$OUT_DIR/src/espnn/"
+  echo "src/espnn/$(basename "$f")" >> "$SCRATCH/espnn_srcs.txt"
+done
 
 echo "[2/5] Runtime, extension and kernel sources copied"
 
@@ -271,6 +281,10 @@ cp "$ET_ROOT/kernels/prim_ops/selective_build_prim_ops.h" \
 mkdir -p "$OUT_DIR/priv_include"
 cp -r "$ET_ROOT/third-party/flatbuffers/include/flatbuffers" \
       "$OUT_DIR/priv_include/flatbuffers"
+# Only espnn_backend.h is the delegate's API; the rest is internal to it.
+cp -r "$ESPNN_RUNTIME/include/espnn" "$OUT_DIR/priv_include/espnn"
+mkdir -p "$OUT_DIR/include/espnn"
+mv "$OUT_DIR/priv_include/espnn/espnn_backend.h" "$OUT_DIR/include/espnn/"
 
 echo "[3/5] Headers and third-party code copied"
 
@@ -283,6 +297,7 @@ LIBRARIES=(
   "portable kernels/portable/functions.yaml"
   "quantized kernels/quantized/quantized.yaml"
   "cadence backends/cadence/aot/functions.yaml"
+  "esp_nn backends/espressif/ops/operators.yaml"
 )
 mkdir -p "$OUT_DIR/tools/libraries" "$OUT_DIR/tools/codegen"
 cp "$TEMPLATE_DIR/tools/gen_kernels.py" "$OUT_DIR/tools/"
@@ -315,7 +330,7 @@ cp "$TEMPLATE_DIR/CMakeLists.txt" "$TEMPLATE_DIR/project_include.cmake" \
    "$TEMPLATE_DIR/README.md" "$OUT_DIR/"
 cp "$TEMPLATE_DIR/include/et_model.h" "$OUT_DIR/include/"
 mkdir -p "$OUT_DIR/src/platform"
-cp "$TEMPLATE_DIR/src/et_model.cpp" "$OUT_DIR/src/"
+cp "$TEMPLATE_DIR/src/et_model.cpp" "$TEMPLATE_DIR/src/espnn_anchor.cpp" "$OUT_DIR/src/"
 cp "$ESP_PAL_SRC" "$OUT_DIR/src/platform/"
 cp "$ET_ROOT/LICENSE" "$OUT_DIR/LICENSE"
 
@@ -349,9 +364,13 @@ NOTICE
   sort -u "$SCRATCH/kernel_srcs.txt" | sed 's/.*/    "&"/'
   echo ")"
   echo "set(ET_PRIM_OPS_SRC \"$(cat "$SCRATCH/prim_src.txt")\")"
+  echo "set(ET_ESPNN_SRCS"
+  sed 's/.*/    "&"/' "$SCRATCH/espnn_srcs.txt"
+  echo ")"
 } > "$OUT_DIR/et_generated.cmake"
 
-cat > "$OUT_DIR/Kconfig" <<'KCONFIG'
+{
+cat <<'KCONFIG'
 # GENERATED by examples/espressif/build_idf_component.sh -- do not edit.
 menu "ExecuTorch"
 
@@ -413,8 +432,12 @@ menu "ExecuTorch"
             Raise this when the application registers its own kernels.
             Must not be below the kernel bundle's kernel count.
 
-endmenu
 KCONFIG
+# The ESP-NN delegate's options, as a submenu.
+sed -n '/^menu /,/^endmenu/p' "$ESPNN_RUNTIME/Kconfig" | sed 's/^./    &/'
+echo ""
+echo "endmenu"
+} > "$OUT_DIR/Kconfig"
 
 sed "s/@ET_COMPONENT_VERSION@/$ET_COMPONENT_VERSION/" \
   "$TEMPLATE_DIR/idf_component.yml.in" > "$OUT_DIR/idf_component.yml"
 
@@ -6,11 +6,13 @@
 
 # Minimal ESP-IDF consumer of the generated ExecuTorch component, used by
 # .ci/scripts/test_espressif_idf_component.sh. Pass the generated component
-# directory as ET_COMPONENT_DIR, the plain smoke .pte from export_smoke_model.py
-# as ET_SMOKE_PTE, and optionally its kernel bundle from the component's
-# tools/gen_kernels.py as ET_SMOKE_KERNELS; without one the build makes it.
-# Without ET_SMOKE_PTE it builds an app that does not use ExecuTorch, for size
-# comparisons.
+# directory as ET_COMPONENT_DIR and the .pte files that split_bundled_program.py
+# made as the ET_SMOKE_MODELS list; each runs on its bundled test case. Pass a
+# kernel bundle from the component's tools/gen_kernels.py as ET_SMOKE_KERNELS,
+# or leave it out to have the build make one. With ET_SMOKE_BACKENDS, the models
+# are embedded but not declared and only those delegates are, as for models
+# delivered over the air. Without ET_SMOKE_MODELS it builds an app that does not
+# use ExecuTorch, for size comparisons.
 
 cmake_minimum_required(VERSION 3.16)