AI Engine Compiler Options - 2021.2 English

The stack, heap, and sync buffer (32 bytes, includes the graph run iteration number information) are allocated up to 32768 bytes of data memory. The default heap size is set to 1024 bytes. Before changing the heap size to a different value, ensure that the sum of the stack, heap, and sync buffer sizes does not exceed 32768 bytes.

Used for allocating any remaining file-scoped data that is not explicitly connected in the user graph.

The stack, heap, and sync buffer (32 bytes) are allocated up to 32768 bytes of data memory. The default stack size is set to 1024 bytes. Before changing the stack size to a different value, ensure that the sum of the stack, heap, and sync buffer sizes does not exceed 32768 bytes.

Used as a standard compiler calling convention including stack-allocated local variables and register spilling.

• The hw target produces a libadf.a for use in the hardware device on a target platform.
• The x86sim target compiles the code for use in the x86 simulator as described in x86 Functional Simulator.

Specify one or more include directories.

This is a path to a Vitis platform file that defines the hardware and software components available when doing a hardware design and its RTL co-simulation.

By default, the compiler writes all outputs to a sub-directory of the current directory, called Work. Use this option to specify a different output directory.

The option string is specified as <kernel-function>:<optionid>=<value>. This option string is included during compilation of generated source files on the AI Engine where the specified kernel function is mapped.

For example, to limit the number of parallel compilations to four, you write -Xelfgen="-j4".

--Xmapper=DisableFloorplanning

These are options to try when the design is either failing to converge in the mapping or routing phase, or when you are trying to achieve better performance via reduction in memory bank conflict.

See the Mapper and Router Options for a list and description of options.

--Xpreproc=-D<var>=<value>

--Xpslinker=-L<libpath> -l<libname>

-Xrouter=enableSplitAsBroadcast

where <value> is one of the following:

• functions
• functions_partial_stalls
• functions_all_stalls
• runtime

• Function transition view without stalls.
• Function transition view with stream/lock/cascade stalls.
• Function transition view with all stalls (stream/lock/cascade/memory).
• Run-time event tracing configuration.

• plio
• gmio

• Set the AI Engine event tracing port to plio
• Set the AI Engine event tracing port to gmio

• xlopt=1
  • Automatic computation of heap size: Enables ease of use using kernel analysis to automatically compute the heap requirements for each AI Engine. Therefore, you do not need to specify the heap size.
  • Guidance: Guidance is provided to highlight unaligned variables, global arrays that can potentially be mapper allocated, improper usage of restrict, and potential read before write conflicts.
• xlopt=2
  • Automatic inline: Automatically inlining functions if it is practical and possible to do so, even if the functions are not declared as __inline or inline.
  • Loop peeling for unrolled loops: Make loop iteration count a multiple of the unrolling factor via peeling. Split a loop into multiple loops based on its iteration count and profitability heuristics, and add flattening pragma on the split loops.
  • Pragma insertion: Automatically infer and insert pragmas in kernel code.
    Note: Compiler optimization (xlopt > 0) reduces debug visibility.

• -xlinline-threshold=T: set the automatic inlining threshold to T (default T = 5000)
• -annotate-pragma: automatic insertion of loop unrolling, pipelining, and flattening pragma (default = true)