Requirements

To use these scripts, you need Python 3.9+ and the following Python modules:

pyelftools==0.27  
tabulate  
colorama  

Additionally, ensure that the Make utility and GNU Arm Embedded tool-chain supporting the Arm® Cortex® M55 (with the ‘arm-none-eabi-’ prefix) are available in your PATH.

Optional Tools

For validating a runtime loadable model on the STM32N6570-DK board, you may optionally install:

• STM32CubeIDE supporting the STM32n6 series (version 1.17.0 or higher)
  
• stm_ai_runner Python package

The STM32_CUBE_IDE_DIR system environment variable can be set to indicate the installation folder.

Generating the specialized c-files

The first step involves generating the specialized files and associated memory initializers. There are no restrictions on the options used for this step, except the usage of the --all-buffers-info option to have all detailed information about the intermediate/activation buffers. Note that these generated extra information are removed during the generation of the runtime loadable model. For the memory-pool descriptor file, the following attributes are mandatory:

• "mode": "USEMODE_RELATIVE“ for external memory pools only (flash and ram). Otherwise, use 'USEMODE_ABSOLUTE'. Note that since v1.3, the external RAM region can be also absolute.
• "fformat": "FORMAT_RAW“ for all memory initializers.

Generate the specialized c-files:

$ stedgeai generate -m <quantize_model> --target stm32n6 --st-neural-art <profile>@<conf_file>

• By default the generated files are stored in the .\st_ai_output folder:

  network.c
  network_atonbuf.xSPI2.raw
  network_c_info.json

• Note that the memory initializers for the memory regions which are only used for the activations are not requested.

Generating the relocatable binary model

The second step involves postprocessing and compiling the output from the first step to generate a binary object (or relocatable module) representing the runtime loadable model. This step ensures that the final code/data size is accurate and ready for deployment.

The npu_driver.py is the entry point for executing the steps required to generate the loadable model. The '--input/-i' is used to specify the location of the generated "network.c" and associated memory initializers (*.raw files). The default value is ./st_ai_output. The '--output\-o' option is used to specify the output folder (default: ./build).

usage: npu_driver.py [-h] [--input STR] [--output STR] [--name STR] [--no-secure] [--no-dbg-info]
                     [--ecblob-in-params] [--split] [--llvm] [--st-clang] [--compatible-mode]
                     [--custom [STR]] [--cross-compile STR]
                     [--gen-c-file] [--parse-only] [--no-clean]
                     [--log [STR]] [--verbosity [{0,1,2}]] [--debug] [--no-color]

NPU Utility - Relocatable model generator v1.3

optional arguments:
  -h, --help            show this help message and exit
  --input STR, -i STR   location of the generated c-files (or network.c file path)
  --output STR, -o STR  output directory
  --name STR, -n STR    basename of the generated c-files (default=<network-file-name>)
  --no-secure           generate binary model for non secure context
  --no-dbg-info         generate binary model without LL_ATON_EB_DBG_INFO
  --ecblob-in-params    place the EC blob in param section
  --split               generate a separate binary file for the params/weights
  --llvm                use LLVM compiler and libraries (default: GCC compiler is used)
  --st-clang            use ST CLANG compiler and libraries (default: GCC compiler is used)
  --compatible-mode     set the compatible option (target dependent)
  --custom [STR]        config file for custom build (default: custom.json)
  --cross-compile STR   prefix of the ARM tool-chain (CROSS_COMPILE env variable can be used)
  --gen-c-file          generate c-file image (DEBUG PURPOSE)
  --parse-only          parsing only the generated c-files
  --no-clean            Don't clean the intermediate files
  --log [STR]           log file
  --verbosity [{0,1,2}], -v [{0,1,2}]
                        set verbosity level
  --debug               Enable internal log (DEBUG PURPOSE)
  --no-color            Disable log color support

$ python $STEDGEAI_CORE_DIR/scripts/N6_reloc/npu_driver.py -i st_ai_output/network.c -o build

   ...
   XIP size      = 29,008    (0x7150) data+got+bss sections
   COPY size     = 173,512   (0x2a5c8) +ro sections
   PARAMS offset = 176,064   (0x2afc0)
   PARAMS size   = 1,793,272 (0x1b5cf8)

   ┌────────────────────────┬────────────────────────────────┬────────┬──────────┬─────────┐
   │ name (addr)            │ flags                          │ foff   │ dst      │ size    │
   ├────────────────────────┼────────────────────────────────┼────────┼──────────┼─────────┤
   │ xSPI2 (20009f84)       │ 01010500 RELOC.PARAM.0.RCACHED │ 0      │ 00000000 │ 1793265 │
   │ AXISRAM5 (20009f8a)    │ 03020200 RESET.ACTIV.WRITE     │ 0      │ 342e0000 │ 352800  │
   │ <undefined> (00000000) │ 00000000 UNUSED                │ 0      │ 00000000 │ 0       │
   └────────────────────────┴────────────────────────────────┴────────┴──────────┴─────────┘
    Table: mempool c-descriptors (off=40005800, 3 entries, from RAM)

   rt_ctx: c_name="network", acts_sz=352,800, params_sz=1,793,265, ext_ram_sz=0
   rt_ctx: rt_version_desc="atonn-v1.1.1-13-g0b0b607eb (RELOC.GCC)"

   Generating files...
    creating "build\network_rel.bin" (size=1,969,336)

Final information returned by the npu_driver.py:

The “mempool c-descriptors” table indicates the memory regions (part of the user memory-pools) and the flags which are considered by the ll_aton_reloc_install() function at runtime.

• The number '0' or '1' indicates the ID of the relocatable memory regions. Currently only two regions are supported: '0' for a params/weights only region in external flash and '1' for a read/write memory region in the external RAM.
  
• 'foff' indicates the offset in the 'params/weights' section to find the associated memory initializer when requested.
• 'dst' indicates the destination address. If not equal to zero, the address is an absolute address otherwise the region is a relocatable region.
• size indicates the size in byte.

   XIP size      = 14,192    (0x3770) data+got+bss sections
   COPY size     = 173,576   (0x2a608) +ro sections
   PARAMS offset = 174,888   (0x2ab28)
   PARAMS size   = 1,966,080 (0x1e0000)

   ┌────────────────────────┬────────────────────────────┬────────┬──────────┬─────────┐
   │ name (addr)            │ flags                      │ foff   │ dst      │ size    │
   ├────────────────────────┼────────────────────────────┼────────┼──────────┼─────────┤
   │ AXISRAM5 (20009f84)    │ 03020200 RESET.ACTIV.WRITE │ 0      │ 342e0000 │ 180000  │
   │ AXISRAM4 (20009f8d)    │ 02030200 COPY.MIXED.WRITE  │ 0      │ 34270000 │ 458752  │
   │ AXISRAM3 (20009f96)    │ 02030200 COPY.MIXED.WRITE  │ 458752 │ 34200000 │ 458752  │
   │ AXISRAM2 (20009f9f)    │ 02010100 COPY.PARAM.READ   │ 917504 │ 34100000 │ 1048572 │
   │ <undefined> (00000000) │ 00000000 UNUSED            │ 0      │ 00000000 │ 0       │
   └────────────────────────┴────────────────────────────┴────────┴──────────┴─────────┘
    Table: mempool c-descriptors (off=40001df8, 5 entries, from RAM)

   rt_ctx: c_name="network", acts_sz=352,815, params_sz=1,793,261, ext_ram_sz=0
   rt_ctx: rt_version_desc="atonn-v1.1.1-13-g0b0b607eb (RELOC.GCC)"

   Generating files...
    creating "build\network_rel.bin" (size=2,140,968)

   XIP size      = 70,984    (0x11548) data+got+bss sections
   COPY size     = 174,816   (0x2aae0) +ro sections
   PARAMS offset = 179,784   (0x2be48)
   PARAMS size   = 1,793,272 (0x1b5cf8)

   ┌────────────────────────┬────────────────────────────────┬────────┬──────────┬─────────┐
   │ name (addr)            │ flags                          │ foff   │ dst      │ size    │
   ├────────────────────────┼────────────────────────────────┼────────┼──────────┼─────────┤
   │ xSPI1 (2000a4a0)       │ 01020601 RELOC.ACTIV.1.WCACHED │ 0      │ 00000000 │ 352800  │
   │ xSPI2 (2000a4a6)       │ 01010500 RELOC.PARAM.0.RCACHED │ 0      │ 00000000 │ 1793265 │
   │ <undefined> (00000000) │ 00000000 UNUSED                │ 0      │ 00000000 │ 0       │
   └────────────────────────┴────────────────────────────────┴────────┴──────────┴─────────┘
    Table: mempool c-descriptors (off=4000fbf8, 3 entries, from RAM)

   rt_ctx: c_name="network", acts_sz=352,800, params_sz=1,793,265, ext_ram_sz=352,800
   rt_ctx: rt_version_desc="atonn-v1.1.1-13-g0b0b607eb (RELOC.GCC)"

“–split” option

This option allows generating two separate files. In this case, to deploy the model, both files should be deployed on the target, and the address of the "network_rel_params.bin" should be passed during the installation process at runtime (see ll_aton_reloc_install() function).

$ python $STEDGEAI_CORE_DIR/scripts/N6_reloc/npu_driver.py -i st_ai_output/network.c -o build --split

...
XIP size      = 28,472    (0x6f38) data+got+bss sections
COPY size     = 169,488   (0x29610) +ro sections
PARAMS offset = 0         (0x0)
PARAMS size   = 0         (0x0)

┌────────────────────────┬────────────────────────────────┬────────┬──────────┬─────────┐
│ name (addr)            │ flags                          │ foff   │ dst      │ size    │
├────────────────────────┼────────────────────────────────┼────────┼──────────┼─────────┤
│ xSPI2 (2000a3bf)       │ 01010500 RELOC.PARAM.0.RCACHED │ 0      │ 00000000 │ 1793265 │
│ AXISRAM5 (2000a3c5)    │ 03020200 RESET.ACTIV.WRITE     │ 0      │ 342e0000 │ 352800  │
│ <undefined> (00000000) │ 00000000 UNUSED                │ 0      │ 00000000 │ 0       │
└────────────────────────┴────────────────────────────────┴────────┴──────────┴─────────┘
Table: mempool c-descriptors (off=400055b4, 3 entries, from RAM)

Generating files...
  creating "build\network_rel.bin" (size=172,032)
  creating "build\network_rel_params.bin" (size=1,793,272)

“–ecblob-in-params” option

The --ecblob-in-params option indicates that the ecblobs (const part) are placed in the params/weights memory section. This feature allows to reduce the requested exec memory region to execute the model in COPY mode. The ecblobs are fetched from the external flash if not copied in exec ram for update. Ecblobs are placed in the beginning of the params/weights memory section. The --split option is always supported, the params file includes the ecblobs.

“–name/-n” option

The --name/-n option allows to specify/overwrite the expected c-name/file-name of the loadable runtime model. By default, the name of the generated network files is used.

Default behavior.

$ python npu_driver.py -i <gen-dir>/network.c 
...
Generating files...
    creating "build\network_rel.bin" (size=..)

$ python npu_driver.py -i <gen-dir>/my_model.c
...
Generating files...
    creating "build\network_rel.bin" (size=..)

$ python npu_driver.py -i <gen-dir>/network.c -n toto
...
Generating files...
    creating "build\toto_rel.bin" (size=..)

LL_ATON stack configuration

Minimal code

The following snippet code illustrates how to install and to use a runtime loadable model within a bare metal environment, single network with a single input tensor, and a single output tensor (epoch controller is used or not). user_model_mgr() function is used to retrieve the address where the module has been flashed.

#include "ll_aton_reloc_network.h"

static NN_Instance_TypeDef nn_instance;  /* LL ATON handle */

uint8_t *input_0, *prediction_0;
uint32_t input_size_0, prediction_size_0;

int ai_init(const uintptr_t file_ptr, const uintptr_t file_params_ptr)
{
  const LL_Buffer_InfoTypeDef *ll_buffer;
  ll_aton_reloc_info rt;
  int res;

  /* Retrieve the requested RAM size to install the model */
  res = ll_aton_reloc_get_info(file_ptr, &rt);
  /* Reserve executable memory region to install the model */
  uintptr_t exec_ram_addr = reserve_exec_memory_region(rt.rt_ram_copy);
  /* Reserve external read/write memory region for external RAM region */
  uintptr_t ext_ram_addr = NULL;
  if (rt.ext_ram_sz > 0)
    ext_ram_addr = reserve_ext_memory_region(rt.ext_ram_sz);

  /* Create and install an instance of the relocatable model */
  ll_aton_reloc_config config;
  config.exec_ram_addr = exec_ram_addr;
  config.exec_ram_size = rt.rt_ram_copy;
  config.ext_ram_addr = ext_ram_addr;
  config.ext_ram_size = rt.ext_ram_sz;
  config.ext_param_addr = NULL;  /* or @ of the weights/params if split mode is used */
  config.mode = AI_RELOC_RT_LOAD_MODE_COPY; // | AI_RELOC_RT_LOAD_MODE_CLEAR;

  res = ll_aton_reloc_install(file_ptr, &config, &nn_instance);

  if (res != 0)
  {
    /* Retrieve the addresses of the input/output buffers */
    ll_buffer = ll_aton_reloc_get_input_buffers_info(&nn_instance, 0);
    input_0 = LL_Buffer_addr_start(ll_buffer);
    input_size_0 = LL_Buffer_len(ll_buffer);
    ll_buffer = ll_aton_reloc_get_output_buffers_info(&nn_instance, 0);
    prediction_0 = LL_Buffer_addr_start(ll_buffer);
    prediction_size_0 = LL_Buffer_len(ll_buffer);

    /* Init the LL ATON stack and the instantiated model */
    LL_ATON_RT_RuntimeInit();
    LL_ATON_RT_Init_Network(&nn_instance);
  }
  return res;
}

void ai_deinit(void)
{
  LL_ATON_RT_DeInit_Network(&NN_Instance_Default); 
  LL_ATON_RT_RuntimeDeInit();
}

void ai_run(void) {
  LL_ATON_RT_RetValues_t ll_aton_ret;
  LL_ATON_RT_Reset_Network(&nn_instance);
  do {
    ll_aton_ret = LL_ATON_RT_RunEpochBlock(&nn_instance);
    if (ll_aton_ret == LL_ATON_RT_WFE) {
      LL_ATON_OSAL_WFE();
      }
  } while (ll_aton_ret != LL_ATON_RT_DONE);
}

void main(void)
{
  uintptr_t file_ptr, file_params_ptr;

  user_system_init();  /* HAL, clocks, NPU sub-system... */

  user_model_mgr(&file_ptr, &file_params_ptr);
  if (ai_init(file_ptr, file_params_ptr)) {
    /*... installation issue ..*/
  }

  while (user_app_not_finished()) {
    /* Fill input buffers */
    user_fill_inputs(input_0);
    /* If requested, perform the NPU/MCU cache operations to guarantee the coherency of the memory. */
    //  LL_ATON_Cache_MCU_Clean_Invalidate_Range(input_0, input_size_0);
    //  LL_ATON_Cache_MCU_Invalidate_Range(prediction_0, prediction_size_0);
    /* Perform a complete inference */
    ai_run();
    /* Post-process the predictions */
    user_post_process(prediction_0);
  }
  ai_deinit();
  //...
}

XIP/COPY execution modes

Memory-pool descriptor files

The "%STEDGEAI_CORE_DIR%/scripts/N6_reloc/test" contains a set of configuration and memory-pool descriptor files which can be used. Here are two main points to consider:

• If nonsecure context is used to execute the deployed model, the base @ of the different memory-pools should be set with a nonsecure address (ex. 0x24350000 instead of 0x34350000 for the AXIRAM6 memory).
• For the memory-pools representing an off-chip device, the "USEMODE_RELATIVE" attribute should be used.

For test purpose with STM32N6570-DK board, different ready-to-use configurations are provided.

For information and test purpose, the *non” reloc memory-pool descriptor files are provided which can be used with a normal deployment flow.

Part of the ./test/mpool/stm32n6_reloc.mpool file:

    ...
    {
        "fname": "AXISRAM6",
        "name":  "npuRAM6",
        "fformat": "FORMAT_RAW",
        "prop":   { "rights": "ACC_WRITE", "throughput": "HIGH", "latency": "LOW",
                    "byteWidth": 8, "freqRatio": 1.25, "read_power": 18.531, "write_power": 16.201 },
        "offset": { "value": "0x34350000", "magnitude":  "BYTES" },
        "size":   { "value": "448",        "magnitude": "KBYTES" }
    },
    {
        "fname": "xSPI1",
        "name":  "hyperRAM",
        "fformat": "FORMAT_RAW",
        "prop":   { "rights": "ACC_WRITE", "throughput": "MID", "latency": "HIGH",
                    "byteWidth": 2, "freqRatio": 5.00, "cacheable": "CACHEABLE_ON",
                    "read_power": 380, "write_power": 340.0, "constants_preferred": "true" },
        "offset": { "value": "0x90000000", "magnitude":  "BYTES" },
        "size":   { "value": "32",         "magnitude": "MBYTES" },
        "mode":   "USEMODE_RELATIVE"
    },
    {
        "fname": "xSPI2",
        "name":  "octoFlash",
        "fformat": "FORMAT_RAW",
        "prop":   { "rights": "ACC_READ",  "throughput": "MID", "latency": "HIGH", 
                    "byteWidth": 1, "freqRatio": 6.00, "cacheable": "CACHEABLE_ON",
                    "read_power": 110, "write_power": 400.0, "constants_preferred": "true" },
        "offset": { "value": "0x70400000", "magnitude":  "BYTES" },
        "size":   { "value": "64",         "magnitude": "MBYTES" },
        "mode":   "USEMODE_RELATIVE"
    }
    ...

“neural_art.json” file

The "%STEDGEAI_CORE_DIR%/scripts/N6_reloc/test" contains two examples of configuration file using the requested memory-pool descriptor files. They provide different profiles using different memory configurations which are aligned with the generic AI test validation.

Part of the ./test/neural_art_reloc.json file:

    ...
    "test" : {
        "memory_pool": "./mpools/stm32n6_reloc.mpool",
        "options": "--native-float --mvei --cache-maintenance --Ocache-opt --enable-virtual-mem-pools --Os
                    --optimization 3 --Oauto-sched --all-buffers-info --csv-file network.csv"
        },
    "test-ec" : {
        "memory_pool": "./mpools/stm32n6_reloc.mpool",
        "options": "--native-float --mvei --cache-maintenance --Ocache-opt --enable-virtual-mem-pools --Os
                    --optimization 3 --Oauto-sched --all-buffers-info --csv-file network.csv --enable-epoch-controller"
        },
    ...

Description

The ll_aton_reloc_install() function acts as a runtime dynamic loader. It is used to install and to create an instance of a memory-mapped runtime loadable module. By providing the model image pointer (file_ptr), configuration details, and neural network instance, users can set up the model for execution. The function performs compatibility checks, initializes memory pools, and installs/relocates code and data sections as needed.

Parameters

• file_ptr: A uintptr_t value representing the pointer to the image of the runtime loadable model. This parameter specifies the location of the model image to be installed.
• config: A pointer to an ll_aton_reloc_config structure. This parameter provides the configuration details for how the model should be installed, including memory addresses and sizes.
• nn_instance: A pointer to an NN_Instance_TypeDef structure. This parameter is updated to handle the installed model, creating an instance of the neural network.

Return Value

• The function returns an integer value. A return value of 0 typically indicates success, while a nonzero value indicates that an error occurred during the installation process.

Steps Executed

1. Checking step
   • This step checks the compatibility of the binary object against the runtime environment (static part of the firmware). The main points checked include:
     • The version and content of the binary file header.
     • MCU type and whether the FPU (floating-point unit) is enabled (context/setting of the caller is used).
     • Secure or nonsecure context.
     • Whether the binary module has been compiled with the LL_ATON_EB_DBG_INFO or LL_ATON_RT_ASYNC C-defines.
     • Version of the used LL_ATON files.
2. Memory-Pool initialization step
   • If requested, this step initializes the used memory regions for the given model. Specifically:
     • If read/write memory pools handle the params/weights section, the associated memory region is initialized with values from the params/weights section.
     • Optionally, if the AI_RELOC_RT_LOAD_MODE_CLEAR flag is set, the read/write memory region handling the activations is cleared.
3. Code/Data installation and relocation step
   • According to the AI_RELOC_RT_LOAD_MODE_COPY or AI_RELOC_RT_LOAD_MODE_XIP flag:
     • The code/data sections are copied into the executable RAM region.
     • The relocation process is performed to update references.
     • Register the call-backs

This function installs and creates an instance of a runtime loadable model referenced by the file_ptr parameter. The config parameter (of type ll_aton_reloc_config) indicates how to install the model, and the nn_instance (of type NN_Instance_TypeDef) is updated to handle the installed model. This function executes the following steps:

ll_aton_reloc_config C-struct

The purpose of the ll_aton_reloc_config C structure is to provide the parameters which are requested to install a runtime loadable model.

typedef struct _ll_aton_reloc_config {
    uintptr_t exec_ram_addr;  /* base@ of the exec memory region to place the relocatable code/data (8-Bytes aligned) */
    uint32_t exec_ram_size;   /* max size in byte of the exec memory region */
    uintptr_t ext_ram_addr;   /* base@ of the external memory region to place the external pool (if requested) */
    size_t ext_ram_size;      /* max size in byte of the external memory region */
    uintptr_t ext_param_addr; /* base@ of the param memory region (if requested) */
    uint32_t mode;
  } ll_aton_reloc_config;

• 'exec_ram_addr'/'exec_ram_size': These members indicate the base address (8-byte aligned) and the maximum size of the read/write executable RAM memory region. These parameters are mandatory. To determine the required size at runtime, the ll_aton_reloc_get_info function can be used.
• 'ext_ram_addr'/'ext_ram_addr': These members indicate the base address (8-byte aligned) and the maximum size of the read/write external RAM memory region, if requested. To determine the required size at runtime, the ll_aton_reloc_get_info function can be used.
• 'ext_param_addr': This member indicates the base address (8-byte aligned) of the memory region containing the parameters/weights of the deployed model. This option is required when the –split option is used; otherwise, it must be set to NULL.
• 'mode': This member indicates the expected execution mode. Or-ed flags can be used. AI_RELOC_RT_LOAD_MODE_XIP or AI_RELOC_RT_LOAD_MODE_CLEAR flag is mandatory. AI_RELOC_RT_LOAD_MODE_CLEAR flag is optional.

Description

The ll_aton_reloc_set_callbacks function is used to overwrite the default registration of the callbacks done in the ll_aton_reloc_install function. This function is optional.

Parameters

• nn_instance: A pointer to the neural network instance (NN_Instance_TypeDef).
• cbs: A pointer to a ll_aton_reloc_callback structure (see ll_aton_reloc_network.h file).

Return Value

• The function returns an integer value. A return value of 0 typically indicates success, while a nonzero value indicates that an error occurred during the installation process.

Description

The ll_aton_reloc_get_info function is used to obtain the main dimensioning information from the image of a runtime loadable model. This information can include details such as the size, memory requirements, and other relevant attributes of the model. By providing a pointer to the model image and a reference to an ll_aton_reloc_info structure, users can retrieve and store the necessary information to properly configure and manage the runtime loadable model.

This function is particularly useful for setting up the memory regions and ensuring that the model can be correctly loaded and executed within the available resources.

Parameters

• file_ptr: A uintptr_t value representing the pointer to the image of the runtime loadable model. This parameter specifies the location of the model image from which the information will be retrieved.
• rt: A pointer to an ll_aton_reloc_info structure. This parameter is used to store the retrieved dimensioning information of the runtime loadable model. The function fills this structure with the relevant details.

Return Value

• The function returns an integer value. A return value of 0 typically indicates success, while a nonzero value indicates that an error occurred during the operation.

ll_aton_reloc_info C-struct

  typedef struct _ll_aton_reloc_info
  {
    const char *c_name;          /* c-name of the model */
    uint32_t variant;            /* 32-b word to handle the reloc rt version,
                                    the used ARM Embedded compiler,
                                    Cortex-Mx (CPUID) and if the FPU is requested */
    uint32_t code_sz;            /* size of the code (header + txt + rodata + data + got + rel sections) */
    uint32_t params_sz;          /* size (in bytes) of the weights */
    uint32_t acts_sz;            /* minimum requested RAM size (in bytes) for the activations buffer */
    uint32_t ext_ram_sz;         /* requested external ram size for the activations (and params) */
    uint32_t rt_ram_xip;         /* minimum requested RAM size to install it, XIP mode */
    uint32_t rt_ram_copy;        /* minimum requested RAM size to install it, COPY mode */
    const char *rt_version_desc; /* rt description */
    uint32_t rt_version;         /* rt version */
    uint32_t rt_version_extra;   /* rt version extra */
  } ll_aton_reloc_info;

Description

The ll_aton_reloc_get_mem_pool_desc function allows to obtain information about the part of the memory-pools which are used for a given model. By providing a pointer to the model image and an index, users can retrieve the necessary information through the returned ll_aton_reloc_mem_pool_desc structure.

The ll_aton_reloc_get_mem_pool_desc function allows users to obtain information about parts of the memory pools used for a given model. By providing a pointer to the model image and an index, users can retrieve the necessary information through the returned ll_aton_reloc_mem_pool_desc structure.

Parameters

• file_ptr: A uintptr_t value representing the pointer to the image of the runtime loadable model. This parameter specifies the location of the model image from which the information will be retrieved.
• index: Index of the requested descriptor.

Return Value

• The function returns a reference of a ll_aton_reloc_mem_pool_desc object. If the specified index is out of range, the function may return NULL.

Example

A typical snippet of code to display memory pool C-descriptors.

  ll_aton_reloc_mem_pool_desc *mem_c_desc;
  int index = 0;

  while ((mem_c_desc = ll_aton_reloc_get_mem_pool_desc((uintptr_t)bin, index)))
  {
    printf(" %d: flags=%x foff=%d dst=%x s=%d\n", index, mem_c_desc->flags,
           mem_c_desc->foff, mem_c_desc->dst, mem_c_desc->size);
    index++;
  }

ll_aton_reloc_mem_pool_desc C-struct

typedef struct _ll_aton_reloc_mem_pool_desc
{
  const char *name; /* name */
  uint32_t flags;   /* type definition: 32b:4x8b <type><data_type><reserved><id> */
  uint32_t foff;    /* offset in the binary file */
  uint32_t dst;     /* dst @ */
  uint32_t size;    /* real size */
} ll_aton_reloc_mem_pool_desc;

AI_RELOC_MPOOL_GET_XXX(flags) macros (see ll_aton_reloc_network.h file) can be used to know the attributes of the memory pool.

Description

The ll_aton_reloc_get_input/output_buffers_info function is used to obtain information about a specific input/output buffer of a neural network instance. This can be useful for understanding the structure and requirements of the input data for the neural network. By providing the neural network instance and the index of the desired input buffer, users can retrieve detailed information about the buffer, such as its size, type, and memory location.

Parameters

• nn_instance: A pointer to the neural network instance (NN_Instance_TypeDef). This parameter specifies the neural network instance for which the input/output buffer information is to be retrieved.
• num: An integer specifying the index of the input/output buffer whose description is to be retrieved. The index is zero-based, meaning that num = 0 refers to the first input buffer, num = 1 refers to the second input buffer, and so on.

Return Value

• The function returns a pointer to a LL_Buffer_InfoTypeDef structure, which contains the description of the specified input/output buffer. If the specified buffer index is out of range, the function may return NULL.

Description

Both ll_aton_reloc_set_input and ll_aton_reloc_set_output functions are used to configure the address of the input and output buffers for a neural network instance, respectively. By providing the neural network instance, buffer index, buffer pointer, and buffer size, users can set up the necessary memory regions for input and output data.

Parameters

• nn_instance: A pointer to the neural network instance (NN_Instance_TypeDef). This parameter specifies the neural network instance for which the output buffer is to be set.
• num: An unsigned integer specifying the index of the output buffer to be set. The index is zero-based.
• buffer: A pointer to the buffer that will hold the output data. This parameter specifies the memory location where the output data is stored.
• size: An unsigned integer specifying the size of the input/output buffer in bytes.

Return Value

• The function returns a value of type LL_ATON_User_IO_Result_t. This return value indicates the result of the operation, such as success or an error code.

Description

Both ll_aton_reloc_get_input and ll_aton_reloc_get_output functions are used to retrieve pointers to the input and output buffers for a neural network instance, respectively. By providing the neural network instance and buffer index, users can obtain direct access to the memory regions used for input and output data.

Parameters

• nn_instance: A pointer to the neural network instance (NN_Instance_TypeDef). This parameter specifies the neural network instance for which the input/output buffer pointer is to be retrieved.
• num: An unsigned integer specifying the index of the output buffer to be retrieved. The index is zero-based.

Return Value

• The function returns a pointer to the output buffer. If the specified buffer index is out of range or an error occurs, the function may return NULL.