Merging Datapaths using Data Processing Graphs

During the last years, the computing performance increased for basically all integrated digital circuits, including FPGAs. They contain more configurable logic blocks, more memory, and more dedicated computing resources like DSP blocks. Thus, FPGAs offer a high degree of fine grained parallelism that cannot be reached with classic SIMD processors like GPUs. Furthermore, their power consumption is usually much lower than for GPUs making them suitable for embedded applications.

However, this enormous computing power is a trade-off with more complex and demanding development as well as long synthesis times. The first is nowadays targeted by HLS tools that simplify the problem formulation. Instead of VHDL or Verilog code a higher level language like C for example is used. The HLS-compilers turn this again into a hardware description language. Nevertheless, the long synthesis times are still a problem, especially for frequently changing applications.

In the CONIRAS project FPGAs were used for continuous runtime verification. Here, the user or tester specifies a set of assertions that the software must fulfill or may not violate. For runtime verification it is essential that the work flow is interactive as assertions change or are specified frequently. To achieve this goal, a set of assertions is transformed from an abstract language into graphs. These are then merged in order to generate a reconfigurable datapath that is adaptable to the current problem within seconds. A comparison showed that this technique outperforms a dynamic partial reconfiguration approach by factors of more than 50x regarding the turnaround times.

A second reason to merge graphs prior to generating the datapath is resource reduction. This was evaluated on the example of hardware accelerators that are generated from C-code using PIRANHA, a plugin for the GCC compiler. As the executed software never starts two accelerators in parallel, the resource utilization on the FPGA can be reduced by sharing common resources.

It turned out that this problem is more many-layered than the fast reconfiguration. The results that could be achieved using the merging approach did not meet the initial expectations. Therefore, modifications and enhancements were implemented and analyzed in order to get a deeper understanding of the problem. From this knowledge gain new or further modified approaches for the merging are derived in the end.

Wie bei fast alle integrierten, digitalen Schaltungen hat auch bei FPGAs die Rechenleistung in den letzten Jahren stetig zugenommen. Sie umfassen immer mehr konfigurierbare Logikblöcke, mehr Speicher und dedizierte Rechenresourcen wie z.B. DSP-Bausteine. FPGAs ermöglichen damit ein sehr hohes Maß an feingranularer Parallelisierung, die mit klassischen SIMD-Prozessoren wie Grafikkarten nicht abgebildet werden kann. Hinzu kommt noch, dass auch die Leistungsaufnahme meist unter der von Grafikkarten liegt und sie damit auch für den Einsatz in eingebetteten Systemen geeignet sind.

Diese enorme Rechenleistung wird allerdings durch deutlich komplexere und anspruchsvollere Entwicklung, sowie durch lange Synthesezeiten erkauft. Ersteres wird inzwischen durch den Einsatz von HLS-Werkzeugen stark vereinfacht. Anstelle von VHDL oder Verilog kommen Hochsprachen wie z.b. C zum Einsatz, die anschließend von den HLS-Compilern in eine Hardwarebeschreibungssprache übersetzt werden. Nichtsdestotrotz sind die langen Synthesezeiten ein Problem für sich häufig ändernde Anwendungen.

Im CONIRAS-Projekt wurden FPGAs für die kontinuierliche Laufzeitverifikation eingesetzt. Hierbei formuliert der Anwender bzw. Tester eine Menge an Annahmen, die ein Programm erfüllen muss oder nicht verletzen darf. Bei der Laufzeitverifikation ist ein interaktiver Arbeitsfluss wichtig, da sich die Annahmen häufig ändern oder weiter präzisiert werden. Um diesen zu erreichen wurden im Projekt eine Reihe von Annahmen aus einer abstrakten Sprache in Graphen umgewandelt und anschließend miteinander überlagert. Erst nach der Überlagerung wird dann ein rekonfigurierbarer Datenpfad generiert, der sich innerhalb von Sekunden an das aktuelle Problem anpassen lässt. Ein Vergleich ergab, dass die Turnaround-Zeiten beim gewählten Ansatz um den Faktor 50 kürzer sind als bei Verwendung von dynamischer partieller Rekonfiguration.

Ein zweiter Grund für die Überlagerung von Graphen vor der Datenpfad-Generierung ist die Reduzierung des Ressourcenverbrauchs. Dies wurde am Beispiel von automatisch erzeugten Hardware-Beschleunigern evaluiert, die von PIRANHA, einem Plugin für den GCC-Compiler, aus C-Code erzeugt wurden. Da die ausgeführte Software nicht mehrere Beschleuniger parallel startet, kann deren Platzverbrauch auf dem FPGA durch die Wiederverwendung von Ressourcen verringert, werden.

Dieses Problem scheint allerdings deutlich vielschichtiger als das der schnellen Rekonfiguration. Die Ergebnisse, die mit dem Überlagerungsansatz erzielt wurden, entsprachen nicht den anfänglichen Erwartungen. Daher wurden verschiedene Verbesserungsmöglichkeiten evaluiert, um eine Analyse des Problems durchzuführen. Aus den dadurch gewonnenen Erkenntnissen lassen sich abschließend Vorschläge zur Modifikation des Ansatzes beziehungsweise neue Ansätze ableiten.