# QNN LPAI Execution
**Transfer model and input files to the target device**
>
>
> Set up a dedicated test directory on the target device or x86 host (for simulation). Copy the following into this directory:
>
>
> - The compiled model binary
> - Input data files
> - A predefined input_list file (for QNN-NET-RUN)
>
>
>
> Ensure that all required QNN and LPAI runtime components are included based on the target platform
> [Execute model using qnn-net-run](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_execution_arm_tutorial.html#qnn-lpai-fastrpc-backend-type) to learn more about necessary components for every configuration.
**Execute the model using qnn-net-run on test platform (simulator or target device)**
>
>
> Execute the model on supported platforms (x86, ARM, DSP). For execution instructions, refer to:
>
> 1. [x86 Lpai backend.](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_backend_model_execution.html#qnn-lpai-sim-execution) The same backend used during offline model generation. It can also simulate how the model would run in real-time, making it useful for testing and validation purposes.
> 2. [ARM Lpai backend.](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_execution_arm_tutorial.html#qnn-lpai-fastrpc-backend-type) This backend is less efficient due to latency introduced by FastRPC communication, which impacts overall performance.
> 3. [Native DSP Lpai backend.](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_execution_direct_tutorial.html#qnn-lpai-direct-mode-backend-type) This backend type is designed to execute directly on the DSP, to run models on this backend, qnn-net-run should be used in direct mode.
[LPAI Simulation behavior](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_backend_model_execution.html#qnn-lpai-sim-execution) illustrates the LPAI simulation on x86 Linux/Windows OS and Hexagon.
# QNN LPAI Backend Simulation
The LPAI backend compiled for x86 platform supports both offline model generation and direct execution using a simulator.
This capability allows clients to debug and deploy their models more quickly on an x86 machine without needing to interact directly with the target device.
Refer the offline model generation page to prepare configuration files ahead [Offline LPAI Model Generation](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_backend_model_generation.html#qnn-lpai-offline-model-generation).
# QNN LPAI Simulation on Linux x86
**LPAI x86 Linux Simulation**
Note
If full paths are not given to `qnn-net-run`, all libraries must be added to
`LD_LIBRARY_PATH` and be discoverable by the system library loader.
**From Quantized model:**
$ cd ${QNN_SDK_ROOT}/examples/QNN/converter/models
$ ${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-net-run \
--backend ${QNN_SDK_ROOT}/lib/x86_64-linux-clang/libQnnLpai.so \
--model ${QNN_SDK_ROOT}/examples/QNN/example_libs/x86_64-linux-clang/libQnnModel.so \
--input_list ${QNN_SDK_ROOT}/examples/QNN/converter/models/input_list_float.txt \
--config_file /path/to/config.json
Copy to clipboard
**From Serialized buffer:**
$ cd ${QNN_SDK_ROOT}/examples/QNN/converter/models
$ ${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-net-run \
--backend ${QNN_SDK_ROOT}/lib/x86_64-linux-clang/libQnnLpai.so \
--retrieve_context ${QNN_SDK_ROOT}/examples/QNN/converter/models/qnn_model_8bit_quantized.serialized.bin \
--input_list ${QNN_SDK_ROOT}/examples/QNN/converter/models/input_list_float.txt \
--config_file /path/to/config.json
Copy to clipboard
Tip
Add the necessary libraries to your `LD_LIBRARY_PATH`:
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${QNN_SDK_ROOT}/lib/x86_64-linux-clang
Copy to clipboard
# QNN LPAI Simulation on Windows x86
**LPAI x86 Windows Simulation**
Follow these steps to run the LPAI Simulation Backend on a Windows x86 system:
Note
If full paths are not given to `qnn-net-run.exe`, all libraries must be added to
`PATH` and be discoverable by the system library loader.
**From Quantized model:**
$ cd ${QNN_SDK_ROOT}/examples/QNN/converter/models
$ ${QNN_SDK_ROOT}/bin/x86_64-windows-msvc/qnn-net-run.exe \
--backend ${QNN_SDK_ROOT}/lib/x86_64-windows-msvc/QnnLpai.dll \
--model ${QNN_SDK_ROOT}/examples/QNN/example_libs/x86_64-windows-msvc/QnnModel.dll \
--input_list ${QNN_SDK_ROOT}/examples/QNN/converter/models/input_list_float.txt \
--config_file /path/to/config.json
Copy to clipboard
**From Serialized buffer:**
$ cd ${QNN_SDK_ROOT}/examples/QNN/converter/models
$ ${QNN_SDK_ROOT}/bin/x86_64-windows-msvc/qnn-net-run.exe \
--backend ${QNN_SDK_ROOT}/lib/x86_64-windows-msvc/QnnLpai.dll \
--retrieve_context ${QNN_SDK_ROOT}/examples/QNN/converter/models/qnn_model_8bit_quantized.serialized.bin \
--input_list ${QNN_SDK_ROOT}/examples/QNN/converter/models/input_list_float.txt \
--config_file /path/to/config.json
Copy to clipboard
Important
Ensure that the `QNN_SDK_ROOT` environment variable is set correctly:
set QNN_SDK_ROOT=C:\path\to\qnn_sdk
Copy to clipboard
Tip
Add the necessary libraries to your `PATH`:
set PATH=%PATH%;%QNN_SDK_ROOT%\lib\x86_64-windows-msvc
Copy to clipboard
Outputs from the run will be located at the default ./output directory.
\_hexagon\_sim\_execution:
# Hexagon Simulator Execution Guide (Advanced – LPAI v6)
This section provides a **detailed, customer‑focused guide** for running, testing,
debugging, and validating the **hexagon\_sim application** using the
`run_hexagon_sim.sh` script.
The guide reflects the **exact behavior implemented in the script**, including
implicit configuration generation and simulator setup that users do not need
to manage manually. Its goal is to help customers:
- Understand what the script configures automatically
- Provide correct inputs and parameters
- Validate functional correctness
- Debug failures systematically and efficiently
Execution targets a **Hexagon v79 simulated environment** with
**LPAI v6 ENPU co‑simulation enabled**.
# Audience
This guide is intended for:
- Customers integrating QNN LPAI models
- Validation and verification engineers
- Developers debugging backend, model, or simulator behavior
A basic understanding of QNN concepts (context, backend, system library)
is assumed. No prior knowledge of Hexagon simulator internals is required.
# What run_hexagon_sim.sh Does
The `run_hexagon_sim.sh` script acts as a **controlled execution harness**
that prepares and launches a Hexagon simulation session with ENPU enabled.
Internally, the script performs the following actions automatically:
1. Determines execution paths and working directory
2. Locates the Hexagon simulator from the SDK
3. Generates required RTOS and ENPU configuration files
4. Determines and creates the output directory
5. Launches `hexagon-sim` with the correct parameters
6. Executes a QNN sample application inside the simulated environment
From a user’s perspective, the complexity is intentionally reduced to:
- One application shared library
- Standard QNN application arguments
All application arguments are forwarded **unchanged**, ensuring behavior is
consistent with execution on real hardware.
# Command Line Interface
## Basic Usage
./run_hexagon_sim.sh {app_so} {app_args}
Copy to clipboard
Where:
- `{app_so}`
Path to the **QNN sample application shared library** built with the
`hexagon_sim` option enabled.
- `{app_args}`
One or more **QNN application arguments** passed directly to the sample
application. The script does not interpret or modify these arguments.
If no arguments are provided, the script prints usage information and exits.
# Environment Variables
The script supports externally defined environment variables, falling back
to defaults if they are not set.
## HEXAGON\_SDK\_PATH
Path to the Hexagon SDK installation. This variable is required to locate
`hexagon-sim` and simulator runtime components.
If not explicitly set, the script uses a built‑in default path.
export HEXAGON_SDK_PATH=/path/to/hexagon-sdk
Copy to clipboard
Failure modes:
- `hexagon-sim not found` → incorrect `HEXAGON_SDK_PATH`
## HEXAGON\_SIM\_PATH
Path to the directory containing Hexagon simulator artifacts and ENPU
components.
If not set, the script defaults to the **directory containing``run\_hexagon\_sim.sh``**.
export HEXAGON_SIM_PATH=/path/to/hexagon_sim_artifacts
Copy to clipboard
# Generated Runtime Configuration
The script automatically generates the following configuration files
in the current working directory on each run.
## QURT RTOS Configuration (`osam.cfg`)
`osam.cfg` is generated to configure a minimal QURT RTOS environment
required by the simulator.
The file references the QURT model distributed with the Hexagon SDK
and is regenerated on each invocation.
## ENPU Co‑Simulation Configuration (`enpu_cosim.cfg`)
`enpu_cosim.cfg` configures ENPU (LPMLA) hardware co‑simulation and includes:
- Two LPMLA hardware instances
- L2VIC configuration
- Qtimer configuration required by QURT
All addresses, interrupts, and hardware parameters are **fixed in the script**
and represent a known‑good ENPU v6 simulation setup.
Users should not modify this file unless explicitly instructed.
# Output Directory Handling
The script determines the output directory as follows:
- If `--output_dir ` is present in the application arguments,
that directory is used
- Otherwise, the default directory `./output` is selected
The script **creates the output directory automatically** before launching
the simulator.
Execution fails if:
- The directory cannot be created
- The path exists but is not a directory
Note
Using a unique output directory per run is strongly recommended
for debugging and result comparison.
# Example: Minimal Working Invocation
The following invocation represents a **baseline sanity test**:
./run_hexagon_sim.sh \
../lib/unsigned/libqnn-sample-app-lpai.so \
--retrieve_context ./model.bin \
--backend ../lib/unsigned/libQnnLpai.so \
--systemlib ../../hexagon_v79/lib/unsigned/libQnnSystem.so
Copy to clipboard
Successful execution confirms:
- Simulator startup
- ENPU configuration validity
- Backend and system library compatibility
# Commonly Used Application Parameters
## `--retrieve_context `
Specifies the serialized QNN context generated by the LPAI backend.
The context encodes:
- Graph structure
- Quantization parameters
- Backend optimizations
Context load failures typically indicate version or backend mismatch.
## `--backend `
Specifies the QNN LPAI v6 backend implementation.
The library must:
- Target Hexagon v79
- Match the backend used during model generation
## `--systemlib `
Specifies the QNN system library providing low‑level runtime services.
This library must match:
- Hexagon v79
- The SDK used by the simulator
## `--input_list `
Specifies a text file listing input data files (one per line).
Each input file must:
- Match expected tensor shapes
- Use correct data types
- Be **pre‑quantized**
## `--output_dir `
Specifies where output files are written. Automatically created by the script.
# Input and Output Quantization Requirements
The QNN sample application executed by `run_hexagon_sim.sh` **does not performquantization or dequantization**.
All inputs and outputs are treated as **already‑quantized tensors**.
This implies:
- Input data **must be pre‑quantized** using the model’s quantization parameters
- Output data is produced in **quantized form**
- Any dequantization or post‑processing must be handled externally
Note
Providing floating‑point input data may not produce a runtime error,
but will result in incorrect or meaningless outputs.
# Execution Flow
At runtime, the following sequence occurs:
1. Argument validation
2. Generation of `osam.cfg`
3. Generation of `enpu_cosim.cfg`
4. Output directory creation
5. Invocation of `hexagon-sim` with:
- Hexagon v79 target
- ENPU v6 co‑simulation
- RTOS and cosim configuration
6. Execution of the QNN sample application
Indicators of successful execution include:
- No startup or backend errors
- Context loaded successfully
- Output artifacts generated as expected
# Debugging and Validation Guidance
Start with simple inputs and a single inference run. Validate:
- Output files are created
- Output sizes and counts are correct
- Quantized outputs dequantize correctly against a reference
Inspect `osam.cfg` and `enpu_cosim.cfg` when:
- Escalating simulator issues
- Comparing runs
- Reproducing failures
# Common Failure Scenarios
- **hexagon-sim not found**
→ `HEXAGON_SDK_PATH` incorrect
- **Shared library load failure**
→ Architecture or ABI mismatch
- **Context creation failure**
→ Incompatible backend or model
- **Execution succeeds but outputs are incorrect**
→ Inputs not quantized or outputs misinterpreted
# Key Limitations
- ENPU configuration is fixed for **LPAI v6**
- Hexagon simulator target is fixed to **v79**
- Intended for **functional validation and debugging**, not
cycle‑accurate performance measurement
[LPAI ARM Backend Type](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_execution_arm_tutorial.html#qnn-lpai-fastrpc-backend-type) illustrates the LPAI ARM backend type execution.
# QNN LPAI ARM Backend Type
**LPAI ARM Backend Type Execution**
Running the LPAI Backend on an Android device via an ARM target is supported exclusively for offline-prepared graphs.
This tutorial outlines the process of preparing the graph on an x86 host and subsequently transferring the serialized
context binary to the device’s LPAI Backend for execution.
To ensure compatibility with a specific target platform, it is essential to use libraries compiled for that particular target.
Examples are provided below. The QNN\_TARGET\_ARCH variable can be utilized to specify the appropriate library for the target.
## Setting Environment Variables on x86 Linux
# Example for Android targets (Not all targets are supported for Android)
$ export QNN_TARGET_ARCH=aarch64-android
# Example for LE Linux targets (If applicable)
$ export QNN_TARGET_ARCH=aarch64-oe-linux-gcc
# Example for QNX targets (If applicable)
$ export QNN_TARGET_ARCH=aarch64-qnx800
# For LPAI v6 HW version
$ export HW_VER=v6
Copy to clipboard
## Prepare config.json file
{
"backend_extensions": {
"shared_library_path": "/data/local/tmp/LPAI/libQnnLpaiNetRunExtensions.so",
"config_file_path": "./lpaiParams.conf"
}
}
Copy to clipboard
Note
To run the LPAI backend on an Android device, the following requirements must be fulfilled:
1. `${QNN_SDK_ROOT}/lib/lpai-${HW_VER}/unsigned/libQnnLpaiSkel.so` has to be signed by client
2. `qnn-net-run` to be executed with root permissions
## Create test directory on the device
$ adb shell mkdir -p /data/local/tmp/LPAI/adsp
Copy to clipboard
## Push the quantized model to the device
$ adb push ./output/qnn_model_8bit_quantized.serialized.bin /data/local/tmp/LPAI
Copy to clipboard
## Push the LPAI related libraries to the device
$ adb push ${QNN_SDK_ROOT}/lib/${QNN_TARGET_ARCH}/libQnnLpai.so /data/local/tmp/LPAI
$ adb push ${QNN_SDK_ROOT}/lib/${QNN_TARGET_ARCH}/libQnnLpaiStub.so /data/local/tmp/LPAI
$ adb push ${QNN_SDK_ROOT}/lib/${QNN_TARGET_ARCH}/libQnnLpaiNetRunExtensions.so /data/local/tmp/LPAI
$ # Additionally, the LPAI requires Hexagon specific libraries
$ adb push ${QNN_SDK_ROOT}/lib/lpai-${HW_VER}/unsigned/libQnnLpaiSkel.so /data/local/tmp/LPAI/adsp
Copy to clipboard
## Push the input data and input lists to the device
$ adb push ${QNN_SDK_ROOT}/examples/QNN/converter/models/input_data_float /data/local/tmp/LPAI
$ adb push ${QNN_SDK_ROOT}/examples/QNN/converter/models/input_list_float.txt /data/local/tmp/LPAI
Copy to clipboard
## Push the qnn-net-run tool
$ adb push ${QNN_SDK_ROOT}/bin/aarch64-android/qnn-net-run /data/local/tmp/LPAI
Copy to clipboard
## Set up the environment on the device
$ adb shell
$ cd /data/local/tmp/LPAI
$ export LD_LIBRARY_PATH=/data/local/tmp/LPAI:/data/local/tmp/LPAI/adsp
$ export ADSP_LIBRARY_PATH="/data/local/tmp/LPAI/adsp"
Copy to clipboard
## Execute the LPAI model using qnn-net-run
$ ./qnn-net-run --backend ./libQnnLpai.so --device_options device_id:0 --retrieve_context ./qnn_model_8bit_quantized.serialized.bin --input_list ./input_list_float.txt
Copy to clipboard
[LPAI Native DSP Backend type](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_execution_direct_tutorial.html#qnn-lpai-direct-mode-backend-type) illustrates the LPAI Native DSP Backend type execution.
# QNN LPAI Native aDSP Backend Type
**LPAI Native DSP Backend Type Execution**
## Overview
The **QNN LPAI Native aDSP Backend Type** is designed to enable efficient execution of the LPAI backend by providing direct access to the DSP (Digital Signal Processor) hardware.
This approach eliminates the overhead associated with data and control transfer via the IPC (Inter-Process Communication) mechanism, resulting in significantly reduced latency and improved runtime performance.
Applications that can access input sources such as audio, camera, or sensors directly on the aDSP can run independently of the main operating system (Linux/Android).
To use the native aDSP path, these applications must be integrated into either the audio or sensor Process domain (PD).
Execution on a physical device using the native aDSP target is supported **exclusively** for **offline-prepared graphs**. This mode does **not** support dynamic graph compilation or runtime graph generation.
To run on a specific target platform, you must use binaries compiled for that platform. The appropriate library can be selected using the QNN_TARGET_ARCH environment variable (see more details below).
## Target Platform Configuration
To deploy the LPAI backend on a specific target, configure the environment using the correct architecture-specific binaries. Set the QNN_TARGET_ARCH variable as shown below:
export QNN_TARGET_ARCH=
Copy to clipboard
Supported target architectures include:
- aarch64-android for Android-based ARM64 platforms
- aarch64-oe-linux-gcc<your version> for LE Linux-based ARM64 platforms
- aarch64-qnx800 for QNX-based ARM64 platforms
- hexagon-v<version> for Qualcomm Hexagon DSP platforms
Important
**Not all target architectures are supported for Android.**
Some platforms are **lack HLOS (High-Level Operating System) support entirely**. In such cases, HLOS deployment instructions do not apply.
Ensure that your target platform supports the necessary runtime environment for LPAI execution. Refer to the [Available Backend Libraries table](https://docs.qualcomm.com/doc/80-63442-10/topic/backend.html#qnn-sdk-backends-table) for platform-specific compatibility and deployment guidance.
## Setting Environment Variables on HLOS Android/Linux
To configure your development or deployment environment on an x86 Linux host, set the following environment variables:
# Example for Android targets (Not all targets are supported for Android)
$ export QNN_TARGET_ARCH=aarch64-android
# Example for LE Linux targets (If applicable)
$ export QNN_TARGET_ARCH=aarch64-oe-linux-gcc
# Example for QNX targets (If applicable)
$ export QNN_TARGET_ARCH=aarch64-qnx800
# For Hexagon versrion
$ export HEX_VER=81
$ export HEX_ARCH=hexagon-v${HEX_VER}
# For LPAI v6 HW version
$ export HW_VER=v6
Copy to clipboard
Note
To execute the LPAI backend on an Android device, the following conditions must be met:
1. The following Lpai artifacts in `${QNN_SDK_ROOT}/lib/lpai-${HW_VER}/unsigned` must be signed by the client:
- `libQnnLpai.so`
- `libQnnLpaiNetRunExtensions.so`
2. The following qnn-net-run artifacts in `${QNN_SDK_ROOT}/lib/${HEX_ARCH}/unsigned` must be signed by the client:
- `libQnnHexagonSkel_dspApp.so`
- `libQnnNetRunDirectV${HEX_VER}Skel.so`
3. `qnn-net-run` must be executed with root permissions.
Prepare config.json file for direct-mode, where `is_persistent_binary` is required for direct-mode:
{
"backend_extensions": {
"shared_library_path": "/data/local/tmp/LPAI/adsp/libQnnLpaiNetRunExtensions.so",
"config_file_path": "./lpaiParams.conf"
},
"context_configs": {
// This parameter should be set for native aDSP LPAI backend
"is_persistent_binary": true
}
}
Copy to clipboard
## Create test directory on the device
$ adb shell mkdir -p /data/local/tmp/LPAI/adsp
Copy to clipboard
## Push the offline LPAI generated model to the device
$ adb push ./output/qnn_model_8bit_quantized.serialized.bin /data/local/tmp/LPAI
Copy to clipboard
## Push the Lpai libraries to the device
$ adb push ${QNN_SDK_ROOT}/lib/lpai-${HW_VER}/unsigned/libQnnLpai.so /data/local/tmp/LPAI/adsp
$ adb push ${QNN_SDK_ROOT}/lib/lpai-${HW_VER}/unsigned/libQnnLpaiNetRunExtensions.so /data/local/tmp/LPAI/adsp
Copy to clipboard
## Push the qnn-net-run libraries to the device
$ adb push ${QNN_SDK_ROOT}/lib/${HEX_ARCH}/unsigned/libQnnHexagonSkel_dspApp.so /data/local/tmp/LPAI/adsp
$ adb push ${QNN_SDK_ROOT}/lib/${HEX_ARCH}/unsigned/libQnnNetRunDirectV${HEX_VER}Skel.so /data/local/tmp/LPAI/adsp
Copy to clipboard
## Push the input data and input lists to the device
$ adb push ${QNN_SDK_ROOT}/examples/QNN/converter/models/input_data_float /data/local/tmp/LPAI
$ adb push ${QNN_SDK_ROOT}/examples/QNN/converter/models/input_list_float.txt /data/local/tmp/LPAI
Copy to clipboard
## Push the qnn-net-run tool and its dependent libraries
$ adb push ${QNN_SDK_ROOT}/bin/${QNN_TARGET_ARCH}/qnn-net-run /data/local/tmp/LPAI
$ adb push ${QNN_SDK_ROOT}/lib/${QNN_TARGET_ARCH}/libQnnNetRunDirectV${HEX_VER}Stub.so /data/local/tmp/LPAI
Copy to clipboard
## Set up the environment on the device
$ adb shell
$ cd /data/local/tmp/LPAI
$ export LD_LIBRARY_PATH=/data/local/tmp/LPAI:/data/local/tmp/LPAI/adsp
$ export ADSP_LIBRARY_PATH="/data/local/tmp/LPAI/adsp"
$ export HW_VER=v6
Copy to clipboard
## Execute the LPAI model using qnn-net-run
$ ./qnn-net-run --backend asdp/libQnnLpai.so --direct_mode --retrieve_context ./qnn_model_8bit_quantized.serialized.bin --input_list ./input_list_float.txt --config_file
Copy to clipboard
[LPAI Native DSP Backend type for WoS](https://docs.qualcomm.com/doc/80-63442-10/topic/lpai_backend_model_execution.html#qnn-lpai-direct-mode-backend-type-winarm) illustrates the LPAI Native DSP Backend Windows on ARM type execution.
# QNN LPAI Native aDSP Backend Type for Windows on Arm
**LPAI Native DSP Backend Type Execution on WoS**
## Overview
The **QNN LPAI Native aDSP Backend Type on WoS (Windows on Snapdragon)** is designed to enable efficient execution of the LPAI backend by providing direct access to the DSP (Digital Signal Processor) hardware.
This approach eliminates the overhead associated with data and control transfer via the IPC (Inter-Process Communication) mechanism, resulting in significantly reduced latency and improved runtime performance.
Applications that can access input sources such as audio, camera, or sensors directly on the aDSP can run independently of the main operating system.
To use the native aDSP path, these applications must be integrated into either the audio or sensor power domain (PD).
Execution on a physical device using the native aDSP target is supported **exclusively** for **offline-prepared graphs**. This mode does **not** support dynamic graph compilation or runtime graph generation.
To run on a specific target platform, you must use binaries compiled for that platform. The appropriate library can be selected using the QNN_TARGET_ARCH environment variable (see more details below).
## Prerequisite
All commands to be executed in windows powershell.
Open C: drive in windows explorer -> Right click anywhere in the window and select “Open in Terminal”
## Target Platform Configuration
To deploy the LPAI backend on a specific target, configure the environment using the correct architecture-specific binaries. Set the QNN_TARGET_ARCH variable as shown below:
REM Example for Windows on Arm targets
$env:QNN_TARGET_ARCH = "aarch64-windows-msvc"
Copy to clipboard
Supported target architectures include:
- aarch64-windows-msvc for Windows on Arm platforms
- hexagon-v<version> for Qualcomm Hexagon DSP platforms
Important
Ensure that your target platform supports the necessary runtime environment for LPAI execution. Refer to the [Available Backend Libraries table](https://docs.qualcomm.com/doc/80-63442-10/topic/backend.html#qnn-sdk-backends-table) for platform-specific compatibility and deployment guidance.
## Setting Environment Variables on WoS device
REM Set target architecture
$env:QNN_TARGET_ARCH = "aarch64-windows-msvc"
REM Set hardware version
$env:HW_VER="v5"
REM Set Hexagon version
$env:HEX_VER="81"
$env:HEX_ARCH="hexagon-v$env:HEX_VER"
REM Set configuration paths where model and configuration files are located
$env:QNN_MODEL_BIN_PATH = "C:\test"
$env:QNN_CONFIG_PATH = "C:\test"
Copy to clipboard
Note
To execute the LPAI backend on a WoS device, the following conditions must be met:
1. The following Lpai artifacts in `$env:QNN_SDK_ROOT\lib\lpai-$env:HW_VER\unsigned` must be signed by the client:
- `libQnnLpai.so`
- `libQnnLpaiNetRunExtensions.so`
2. The following qnn-net-run artifacts in `$env:QNN_SDK_ROOT\lib\$env:HEX_ARCH\unsigned` must be signed by the client:
- `libQnnHexagonSkel_dspApp.so`
- `libQnnNetRunDirectV$($env:HEX_VER)Skel.so`
Prepare config.json file for direct-mode, where `is_persistent_binary` is required for direct-mode:
{
"backend_extensions": {
"shared_library_path": "libQnnLpaiNetRunExtensions.so",
"config_file_path": "lpaiParams.conf"
},
"context_configs": {
"is_persistent_binary": true
}
}
Copy to clipboard
Prepare lpaiParams.json file as given below:
{
"lpai_backend": {
"target_env": "adsp",
"enable_hw_ver": "v5"
}
}
Copy to clipboard
## Deployment Steps on WoS Device
1. **Create test directory**
mkdir C:\qnn\LPAI
Copy to clipboard
2. **Copy Configuration Files**
copy $env:QNN_CONFIG_PATH\config.json C:\qnn\LPAI
copy $env:QNN_CONFIG_PATH\lpaiParams.conf C:\qnn\LPAI
Copy to clipboard
3. **Copy offline LPAI generated model**
copy $env:QNN_MODEL_BIN_PATH\qnn_model_8bit_quantized.serialized.bin C:\qnn\LPAI
Copy to clipboard
4. **Copy input data and input lists**
copy $env:QNN_MODEL_BIN_PATH\input_list.txt C:\qnn\LPAI
Copy-Item -Path "$env:QNN_MODEL_BIN_PATH\inputs" -Destination "C:\qnn\LPAI" -Recurse -Force
Copy to clipboard
5. **Copy LPAI libraries**
copy $env:QNN_SDK_ROOT\lib\lpai-$env:HW_VER\unsigned\libQnnLpai.so C:\qnn\LPAI
copy $env:QNN_SDK_ROOT\lib\lpai-$env:HW_VER\unsigned\libQnnLpaiNetRunExtensions.so C:\qnn\LPAI
Copy to clipboard
6. **Copy qnn-net-run libraries**
copy $env:QNN_SDK_ROOT\lib\$env:HEX_ARCH\unsigned\libQnnHexagonSkel_dspApp.so C:\qnn\LPAI
copy $env:QNN_SDK_ROOT\lib\$env:HEX_ARCH\unsigned\libQnnNetRunDirectV$($env:HEX_VER)Skel.so C:\qnn\LPAI
Copy to clipboard
7. **Copy qnn-net-run tool and dependencies**
copy $env:QNN_SDK_ROOT\bin\$env:QNN_TARGET_ARCH\qnn-net-run.exe C:\qnn\LPAI
copy $env:QNN_SDK_ROOT\lib\$env:QNN_TARGET_ARCH\QnnNetRunDirectV$($env:HEX_VER)Stub.dll C:\qnn\LPAI
Copy to clipboard
8. **Set up environment and execute model**
cd C:\qnn\LPAI
$env:PATH="C:\qnn\LPAI;$env:PATH"
qnn-net-run.exe --backend libQnnLpai.so --direct_mode --retrieve_context qnn_model_8bit_quantized.serialized.bin --input_list input_list_float.txt --config_file config.json
Copy to clipboard
Note
The output folder for WoS is always relative to the driver fastrpc path: C:\Windows\System32\drivers\DriverData\Qualcomm\fastRPC
- For example:
- qnn-net-run --output test\_output
The output files will be found at: C:\Windows\System32\drivers\DriverData\Qualcomm\fastRPC\test\_output
- For example:
- qnn-net-run --output .\another\_test\output
The output files will be found at: C:\Windows\System32\drivers\DriverData\Qualcomm\fastRPC\another\_test\output
Last Published: Jun 04, 2026