Access Official Technical PDF

Share Summary:LinkedInEmail

FPGA manycore architectures can bring parallel processing resources into embedded systems, but adding cores does not guarantee proportional performance gains. A comparison of two 32-core designs—one asymmetric and one symmetric—illustrates how core placement, memory access and application behavior shape the results. For engineers evaluating FPGA-based acceleration, the findings offer a practical reminder: architecture and workload need to be considered together.

Two ways to organize a 32-core FPGA

Both designs use 32 MicroBlaze soft processor cores: one host core and 31 slave cores. The host runs Linux and manages most application activity, while the slave cores run lightweight runtime software and accelerate selected parallel tasks. In both designs, only the host has a memory management unit.

The key difference is where the host sits in the interconnect topology:

  • ASYM32: The host connects to the top-level AXI4 bus. The slave cores are arranged in four hierarchical clusters, each containing seven or eight slaves.
  • SYM32: The host is placed inside one of four clusters. Each cluster contains eight cores, including the host in its cluster.

Each core has local memory, instruction and data caches. In the reported configurations, the host has 16 KB of local memory and 16 KB instruction and data caches; each slave has 4 KB of local memory and 1 KB instruction and data caches. The cores access program data and code in off-chip DDR3 DRAM through their caches. On-chip SRAM provides a communication path between cores.

FPGA manycore architectures depend on interconnect behavior

Moving the host changes how it reaches memory and how its traffic interacts with slave-core traffic. This was visible in Linux boot measurements. With the Linux image stored in board DRAM, ASYM32 booted faster than SYM32 in the tested setup. The explanation was the path to DRAM: in ASYM32, the host and DRAM controller share the same AXI4 bus, while in SYM32, a cache miss requires access through two AXI4 buses, increasing access latency.

Cache capacity also mattered. Increasing the host’s instruction and data cache sizes improved Linux boot time on both designs. This highlights a design consideration for embedded systems: evaluating compute resources without accounting for memory hierarchy can miss a significant part of system behavior.

Core selection can reduce unnecessary contention

The software framework allowed applications to use a chosen number of slave cores rather than activating all 31. It also offered two ways to select cores:

  • Packed: Select the required cores from the same cluster.
  • Balanced: Spread selected cores across clusters, choosing one from each cluster where applicable.

This choice can affect the communication paths shared by active cores. In the grayscale conversion tests, the balanced method outperformed the packed method in most cases when fewer than all slave cores were active. The reported explanation was reduced memory-access contention. The result is not a universal rule for every application, but it shows why core allocation can be part of performance tuning—not just the total number of cores.

Workload characteristics determine scaling

Three applications were tested: Gaussian filtering, grayscale conversion and run-length encoding. Their results show different limits to parallel execution.

Memory-intensive processing

For Gaussian filtering, adding slave cores generally improved performance, but gains were small beyond four cores. Active cores accessed on-chip SRAM, while off-chip DRAM was also subject to congestion. The slave instruction caches were only 1 KB, too small to hold the full program, so frequent instruction-cache misses further limited scaling. ASYM32 and SYM32, and the packed and balanced selection methods, showed little performance difference for this workload.

Host activity and shared SRAM

For grayscale conversion using all 31 slaves, SYM32 performed better than ASYM32. During parallel execution, the host polls on-chip SRAM addresses to check whether the slaves have finished. Those repeated accesses can compete with slave data traffic. In ASYM32, the host’s direct connection to the SRAM made this interference more pronounced. In SYM32, bus arbitration could block host requests at a lower-level bus, allowing slave cores to access SRAM more quickly in the tested configuration.

Synchronization limits parallelism

Run-length encoding achieved its best result with SYM32 using two slave cores. Compared with the other benchmarks, it required more frequent synchronization among cores, limiting opportunities to divide the work effectively. Activating more processors is therefore not necessarily beneficial when coordination overhead constrains the parallel workload.

Practical implications for embedded system design

The FPGA implementation and measurements demonstrate that neither topology is best for every task. ASYM32 offered a shorter Linux boot time in the reported configuration, while SYM32 performed better in particular application conditions. Memory traffic, cache capacity, host polling, bus arbitration and synchronization all contributed to those differences.

For engineering teams assessing FPGA acceleration, the practical approach is to evaluate representative applications on the intended architecture. Measure performance with different core counts and core-selection strategies, and examine memory behavior alongside execution time. A 32-core design provides parallel resources, but effective acceleration depends on whether the workload can use them without being constrained by shared memory or coordination. Architecture selection should therefore follow measured application needs rather than core count alone.

Access Official Technical PDF

About The Author