Programming an FPGA: An Introduction to How It Works

The architecture of FPGAs makes them an efficient solution for hardware acceleration. Devices such as ASICs and GPUs use an antiquated method of jumping between programming and memory. They also don’t accommodate applications where real-time information is needed, since the high amount of power required for storage and retrieval tasks causes performance lags. 

Unlike ASICs and GPUs, FPGAs don’t need to jump between memory and programming, which makes the process of storing and retrieving data more efficient. And since FPGA architecture is more flexible, you can customize how much power you’d like an FPGA to utilize for a specific task. 

That flexibility can help offload energy-consuming tasks to one or several FPGAs from a conventional CPU or another device. And since many FPGAs can be reprogrammed, you can easily implement upgrades and adjustments to a hardware acceleration system.

FPGA programming uses an HDL to manipulate circuits depending on what capabilities you want the device to have. The process is different from programming a GPU or CPU, since you aren’t writing a program that will run sequentially. Rather, you’re using an HDL to create circuits and physically change the hardware depending on what you want it to do.

The process is similar to programing software in that you write code that is turned into a binary file and loaded onto the FPGA. But the outcome is that the HDL makes physical changes to the hardware, rather than strictly optimizing the device to run software.

A program on an FPGA pieces together lower-level elements like logic gates and memory blocks, which work in concert to complete a task. Because you’re manipulating the hardware from the ground up, FPGAs allow a great deal of flexibility. You can adjust basic functions such as memory or power usage depending on the task.

It might seem that FPGAs primarily lie in the domain of chip designers, rather than engineers who specialize in software development. After all, most HDLs used to write FPGA code are lower-level languages that hardware engineers are likely more familiar with than software engineers. But some HDLs are more similar to common software languages than you might think. 

When we use the word “programming” in regard to FPGAs, it’s not exactly the same as creating software, due to the way the program is set up and how it is executed. But using this term does encompass the idea that writing and executing FPGA code is similar in process to creating a software algorithm. The old way of thinking was that FPGAs could only be programmed by hardware engineers designing at the circuit level. Today, that's no longer the case.

With the help of unified software platforms, software developers can use their preferred languages to program FPGAs without being well versed in HDLs. That takes the stress out of having to pivot to a new programming language, and it can help software developers focus on concepts rather than hardware. These platforms work by essentially translating higher-level languages to lower-level ones so that an FPGA can execute the desired function. Languages that can be used with unified software platforms to program FPGAs include:

• AI framework like TensorFlow and Pytorch - With Vitis AI, AI scientists can now directly take their trained deep learning models from TensorFlow or Pytorch and compile for FPGA acceleration. This not only eliminates the need for low-level hardware programming, but it also achieves blazing-fast compilation time in minutes, matching the typical software compiling experience using CPUs and GPUs.

• C and C++ - Thanks to high-level synthesis (HLS), C-based languages can now be used for FPGA design. Specifically, the Xilinx® Vivado® HLS compiler provides a programming environment that shares key technology with both standard and specialized processors for the optimization of C and C++ programs. This allows software engineers to optimize code without having to deal with the roadblock of limited memory space or computational resources. 

• Python - Designers can use the Python language and libraries to create high-performance applications and program FPGAs with PYNQ—an open-source project from Xilinx that makes it easier to use Xilinx platforms.

There are also a number of mainstream HDLs that are primarily used in FPGA programming today. Here’s a brief rundown on their names and main attributes:

• Lucid - This language was made specifically for FPGAs and overcomes some of the pitfalls of more archaic languages, such as Verilog.

• VHDL - An acronym for VHSIC (Very High Speed Integrated Circuits) Hardware Description Language, this language first appeared in the 1980s and was based off of Ada and Pascal.

• Verilog - The first HDL ever created, Verilog today is used mainly for test analysis and verification. The core of this language was based on C.

The Vitis™ Unified Software Platform is a cutting-edge application that streamlines the FPGA programming process for software engineers, data scientists, and AI developers. It includes an expansive open-source library optimized for Xilinx FPGA and ACAP hardware platforms, and a core development kit that allows you to seamlessly build accelerated applications without extensive hardware experience.

Vitis™ also includes the Vitis Model Composer, which offers a toolbox within MATLAB® and Simulink®. It streamlines the process of designing and testing new applications.

While FPGAs might seem daunting to program without hardware expertise, platforms like Vitis™ make the process accessible for software developers. Xilinx is the top FPGA vendor by revenue and an industry leader in offering resources for software engineers to create FPGA applications.

Using the Xilinx Vitis™ HLS Tool for FPGAs, you can program functions in C, C++, and OpenCL™ and integrate them onto hardware. The HLS tool automates code modifications to make updates simple and optimizes C/C++ code for low latency and high throughput in each of your applications.