CPU‑FPGA Co‑Design Versnellen: Een Practische Flow voor Softwareontwikkelaars

Onlangs organiseerde Brian Bailey een rondetafel die uitmondde in het tweedelige artikel Supporting CPUs + FPGAs. Experts discussieerden de evoluerende realiteit van systemen die FPGA's met CPUs fusioneren, met de nadruk op hoe verse design flows softwareontwikkelaars in staat stellen CPU-plus-FPGA platforms sneller op de markt te brengen.

Inleiding
De golf van kunstmatige intelligentie, de explosie van verbonden apparaten, en de versnelling van datacenter workloads wijzen allemaal naar één gemeenschappelijke drijfveer: softwareontwikkelaars die snelheid zoeken. Laag-latentie links tussen FPGA's en CPUs, gecombineerd met de bescheiden power enveloppen van moderne FPGA's, maken hybride CPU-FPGA systemen een natuurlijke keuze voor veeleisende prestaties. Toch stelt de onderliggende complexiteit van FPGA-technologie ontwikkelaars vaak op een been.

High-Level Synthesis (HLS) tools zijn aanzienlijk gevorderd, wat de mapping van C/C++ naar hardware vergemakkelijkt. Toch zijn ze primair IP-gericht en tekortschieten op systeem-niveau beslissingen – balanceren van software versus hardware taken, kiezen tussen gepipelined of parallelle uitvoering, data-granulariteit tunen, of optimale communicatiemechanismen selecteren.

Wat software-engineers nodig hebben is een unified design flow die voelt als een standaard software IDE maar hardware-aware feedback levert. Recente commerciële oplossingen hebben begonnen deze kloof te dichten door low-level details te abstraheren terwijl de controle die ontwikkelaars eisen behouden blijft. Deze tools zijn gegrondvest in de System-Level Design filosofie uiteengezet in ESL Models and Their Application.

De System-Level Design Flow Begrijpen
System-Level Design werkt op hogere abstractie, valideert, verfijnt en integreert systeemcomponenten vóór implementatie. Meeste ontwerpers starten op algoritmisch niveau, C/C++/SystemC, MATLAB, Simulink, of LabVIEW modellen schrijvend die het volledige systeemgedrag vangen.

We focussen op een C/C++-centrische flow (zie Figuur 1). De eerste stap – applicatie profiling – identificeert welke functies of lussen baat kunnen hebben bij hardware-versnelling. Vervolgens wordt het doel CPU/FPGA platform gespecificeerd (bijv. ARM-Cortex-A53 + FPGA) en de parameters (klok, cache, interconnects) geconfigureerd. Ten slotte worden de geprofileerde taken gemapt tussen software en hardware, wat resulteert in een uitvoerbare architectuur.

Figuur 1. Typische system-level design flow voor CPU/FPGA (Bron: Space Codesign Systems, Inc.)

Het tweede blok van Figuur 1 dekt architectuur-optimalisatie – soms architectural exploration of performance verification genoemd – getoond in meer detail in Figuur 2.

Figuur 2. Architectuur-optimalisatieproces (Bron: Space Codesign Systems, Inc.)

Drie sleutel-estimators voeden deze fase:

• Hardware schatting evalueert de impact van C/C++ code op de FPGA, met breakdown van resourcegebruik, lus-latentie, en power. Het steunt op HLS outputs.
• Software schatting meet CPU-zijde metrics – processorbelasting, task switching, cache misses – complementerend het hardware-zicht.
• Data-transfer schatting modelleert interfaces (memory-mapped of streaming), vastlegend bus-latentie, doorvoer, wachtrijdiepte, en geheugenvoetafdruk.

Geaggregeerde resultaten vullen een database, wat ontwikkelaars in staat stelt te verifiëren of systeemdoelstellingen gehaald worden. Architecturen die aan de criteria voldoen gaan door; anders worden verdere optimalisatie-iteraties getriggerd.

Het laatste blok van Figuur 1 betreft architectuur-implementatie: high-level ontwerpen worden vertaald naar FPGA bitstreams met vendor tools zoals Xilinx Vivado of Intel Quartus Prime, wat een volledig gesynthetiseerd en testbaar systeem oplevert klaar voor deployment.

System-Level Optimalisatie
Het ontbreken van geautomatiseerde, end-to-end optimalisatietools is lang een knelpunt geweest in FPGA-gebaseerde computing. De complexiteit van het balanceren van meerdere ontwerpdimensies maakt handmatige exploratie vervelend, zelfs voor ervaren ontwerpers.

Figuur 3 illustreert een typische optimalisatieworkflow voor een beeldverwerkingsapplicatie bestaande uit zes C/C++ functies gedeployed op een Zynq-7000 platform. Acht kandidaten-architecturen worden overwogen, maar time-to-market constraints eisen een snelle selectie van de beste compromie tussen prestaties, oppervlakte, en power.

Figuur 3. Architectuur-exploratie met system-level decisions gehighlight (Bron: Space Codesign Systems, Inc.)

Commerciële oplossingen zoals Xilinx's SDSoC/SDAccel, Falcon Computing's Merlin Compiler, en Space Codesign's SpaceStudio bieden nu end-to-end ondersteuning. Ze spiegelen de flow in Figuur 1 en 2 terwijl ze geautomatiseerde beslissingslogica injecteren:

• SDSoC schaalt latenties voor hardware kernels en karakteriseert data transfer op het doelplatform, daarna benchmarkt tegen een pure-software run.
• Merlin Compiler past source-to-source transformaties toe gedreven door vier pragmas, plus impliciete compiler passes die pipelining en parallelisme boosten.
• SpaceStudio bouwt een virtueel platform (VP) dat het hele systeem simuleert, hardware-gegenereerde latenties integrerend en non-intrusieve profiling biedend van zowel software als hardware taken.

Een Kijk op het Commerciële Ecosysteem
Figuur 4 presenteert een gelaagde kijk op het ecosysteem rondom CPU/FPGA platform design. De top layer toont algoritmische entry points; de middelste layer host tools die system-level optimalisaties van C/C++ ondersteunen; de bottom layer bevat vendor synthesis tools die bitstreams produceren. Vertegenwoordigende CPU/FPGA platforms geïllustreerd aan de basis.

Figuur 4. Commerciële ecosysteem voor CPU/FPGA platforms (Bron: Space Codesign Systems, Inc.)

Tabel 1 lijst sleutel commerciële automation tools gebruikt in CPU/FPGA platform design.

Tabel 1. Commerciële automation tools (*Let op: Een lijst wordt voorgesteld in deze review)

Conclusie
Het democratiseren van CPU-plus-FPGA ontwikkeling is het uiteindelijke doel, wat een bredere schare softwareontwikkelaars in staat stelt hardware-versnelling te benutten. Net als de software-industrie evolueerde van assembly naar Python en Swift over vijf decennia, ondergaat FPGA-programmering een vergelijkbare volwassenwording. De opkomst van system-level tools als SpaceStudio, SDSoC, en Merlin Compiler signaleert een cruciale shift – doch volledige automatisering en naadloze optimalisatie cross-compilers blijven toekomstige mijlpalens.

Guy Bois, Ing., PhD is de Founder van Space Codesign Systems en Professor in de Department of Software and Computer Engineering aan Polytechnique Montréal. Met uitgebreide R&D ervaring naast industrie-leiders – STMicroelectronics, Grass Valley, PMC Sierra, Design Workshops Technologies, en Cadabra Systems – leidde Guy's expertise in hardware/software co-design tot de commercialisatie van SpaceStudio en de oprichting van Space Codesign Systems Inc.