bare-metal MCUs No BufferDataLoader ?

[Faboulou]

Hello !

Problem Description

I’m currently working on deploying ExecuTorch on a bare-metal microcontroller featuring an Arm Cortex-M + Ethos-U55 NPU.

The .pte model is stored in external QSPI flash and must be executed XIP.

However, when configuring the CMake build for bare-metal, the system disables all data loader extensions:

-DEXECUTORCH_BUILD_ARM_BAREMETAL=ON
-DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=OFF # (forced by compatibility)

In the current ExecuTorch examples and documentation — particularly in
backends/cadence/executor_runner.cpp
— the BufferDataLoader is the only documented method to load a .pte.

Unfortunately, this class resides in the extensions module and cannot be used in a bare-metal build. That leaves some uncertainty about how to properly load a model directly from external flash (XIP) when extensions are disabled.

I’m hoping to clarify a few key points and open discussion around the official or recommended path for this scenario.

Questions

• What is the intended mechanism to load the model when using bare-metal + XIP?
• For the Ethos-U55 backend, is there a required initialization step for the delegate in bare-metal environments?

Thanks in advance

[asiimhusain]

#include "executor.hpp"

// Linker symbols for .pte in QSPI flash
extern const uint8_t exec_model_start[];
extern const size_t exec_model_size;

// Tensor arena in SRAM
uint8_t tensor_arena[256 * 1024]; // adjust size

int main() {
exec::Options opts;
opts.use_ethos_u55 = true;
opts.tensor_arena = tensor_arena;
opts.tensor_arena_size = sizeof(tensor_arena);

exec::Program program(opts);

// Load model directly from XIP flash
program.load(exec_model_start, exec_model_size);

// Run model
program.run();

return 0;

}

[Faboulou]

Hi @asimhusain-ai !

Thank you for sharing your example.

I believe there might be a few API differences compared to the current ExecuTorch runtime:

• The Program::load() method actually expects a DataLoader* (for example BufferDataLoader), not raw pointers to model data.

• There’s no Options struct in the current ExecuTorch

• the Program class doesn’t have a run() method

• when cross-compiling for ARM targets, program.h isn’t available — only a reduced runtime API is built for embedded use.

So your snippet may compile against an experimental branch, but not against the current mainline ExecuTorch :/

Thanks again for sharing it

[GregoryComer]

@JacobSzwejbka @psiddh @digantdesai Do you have any suggestions on how to best handle this?

[psiddh]

@Faboulou Thanks for raising this issue, One option I could think of is to follow our recently added Pico2 bare metal tutorial which demonstrates exactly this - loading and executing .pte files in bare metal environments with BufferDataLoader

Note: ‘build_firmware_pico.sh’ script converts given model pte to hex array and generates C code for the same via this helper script. This C code is then compiled to generate final .uf2 binary which is then flashed to Pico2.

tl;dr: The Pico2 bare-metal stcok tutorial uses BufferDataLoader with embedded .pte data.
The key is that BufferDataLoader can work with static embedded data - you don't need filesystem access, just a memory buffer.

Try:

1. Enable extensions in your bare-metal build - the "forced compatibility" might not apply to your setup ?
2. Use BufferDataLoader with embedded data like Pico2 does
3. Check the actual Pico2 CMake configuration to see what flags are used

Let us know if this helps!

[Faboulou]

Hey @psiddh

I was able to use BufferDataLoader, seems to work ( I just upgrade my executorch to v0.7 to v1.0.0)

        BufferDataLoader loader(p, sz_real);
        et::Result<et::Program> program = et::Program::load(&loader);

Thanks for the pico2 tutorial, it was useful :)