How to Program FPGAs: Key Concepts and Best Practices

This article explores essential concepts and best practices for FPGA programming, guiding through developing efficient and effective designs using hardware description languages (HDLs) like VHDL and Verilog. FPGAs are used in various industries, including high-frequency trading (HFT), where they have found critical applications due to their low latency and high throughput capabilities.

What tools and software do you need?

To begin programming FPGAs, you need a comprehensive toolset. An integrated development environment (IDE) designed for FPGA programming is essential. The biggest manufacturers of FPGAs, AMD and Intel, provide their own proprietary IDEs (AMD Vivado and Intel Quartus Prime) required for programming their chips. These IDEs provide a unified platform for design entry, simulation, synthesis, and implementation. You can also invest in an advanced HDL simulator like ModelSim to test and verify your designs before implementation, though the simulator included with your IDE is sufficient for many use cases. These simulators support both VHDL and Verilog.

Most modern FPGA development boards come with built-in USB programming interfaces. This interface also usually provides access to integrated logic analyzers (ILA) which are beneficial for debugging and verifying the behavior of implemented designs.

How to choose the right FPGA board for beginners?

Consider factors like the number of logic elements, I/O pins, and built-in features. A board with a good balance of capability and simplicity is ideal for beginners. Look for boards with onboard peripherals like LEDs, switches, and displays, which are helpful for testing. Popular options include the Xilinx Artix-7 based boards or Intel's DE-series.

 Consider the board's long-term potential, too. While you might start with simple projects, choosing a board with room for growth allows you to tackle more complex designs, perhaps even moving into HFT applications, as your skills improve. Ensure board compatibility with your chosen development tools to streamline the learning process.

 Equally important is the availability of learning resources and community support. Many manufacturers offer starter kits with tutorials, example projects, and documentation tailored for beginners. 

Setting up your development environment

Start by installing your chosen IDE (Xilinx Vivado or Intel Quartus Prime) on a computer meeting the software's requirements. These IDEs usually include simulators, synthesis tools, and programming utilities. After installation, familiarize yourself with the IDE's interface and workflows. Install any additional simulation tools, like ModelSim, and ensure their proper integration with your primary IDE. 

Next, connect your FPGA development board and install any necessary drivers. Configure your IDE to recognize your board by selecting the correct device family and model. Employ version control systems like Git to manage design versions and facilitate collaboration. Finally, organize your workspace with separate directories for projects and use a consistent file naming convention. A well-organized environment enhances productivity and simplifies managing complex designs.

Understanding Hardware Description Languages

Hardware Description Languages (HDLs) are specialized languages used to describe digital circuits.

What is VHDL?

VHDL (VHSIC Hardware Description Language, where VHSIC stands for Very High Speed Integrated Circuit) is a widely used HDL for programming FPGAs. Developed in the 1980s, VHDL provides a standardized way to describe digital systems' structure and behavior. It allows engineers to model circuits at various abstraction levels, from high-level system descriptions to low-level gate implementations. 

VHDL's strong typing system helps catch errors early. It supports both behavioral and structural modeling, enabling designers to describe circuit behavior and construction. The language features concurrent execution, aligning with hardware's parallel nature. VHDL's verbose, self-documenting syntax promotes clear, maintainable code. The use of 'entities' and 'architectures' allows for modular design and code reuse. This modularity is highly valued in complex systems like those used in high-frequency trading.

What is Verilog?

Verilog is another popular HDL used for modeling electronic systems, especially in digital circuit design and verification. Developed in the 1980s and later standardized, Verilog, like VHDL, allows designers to describe systems at various abstraction levels. It provides a means to simulate and synthesize complex digital circuits, including those used in time-sensitive applications like HFT, before physical implementation.

 Verilog's syntax is more C-like, potentially making it easier to learn for those with a software background. It supports behavioral and structural modeling, describing both function and structure. Verilog uses 'modules' as primary design units, promoting code reuse and hierarchical design. Its concise syntax can lead to more compact code. The language also supports system tasks and functions for simulation control, making it perfect for testbench development and verification, which are vital in HFT for ensuring system reliability.

VHDL vs. Verilog: Which one should you learn?

VHDL's verbose syntax can lead to self-documenting code and early error detection. It's popular in the defense and aerospace industries. Verilog, with its C-like syntax, might be more intuitive for those with software experience and is widely used in the semiconductor industry, including many HFT firms.

 Which is better to learn first? For beginners, the decision might hinge on available resources and the predominant language in their target industry or academic program. Many experts recommend eventually learning both, given the increasing use of mixed-HDL environments. Some projects, especially in specialized fields like HFT, even mix VHDL and Verilog.

Key Concepts in FPGA Programming. What are logic gates?

Logic gates are fundamental to digital circuits and FPGA programming. These devices perform basic logical operations on binary inputs, producing a single binary output. Common types include AND, OR, NOT, NAND, NOR, XOR, and XNOR, each with a unique truth table. In FPGAs, these gates are implemented using Look-Up Tables (LUTs), programmable elements that can perform any logical function. 

Designers use HDLs to describe desired logical operations, which are then synthesized into logic gate configurations within the FPGA's programmable fabric. Complex circuits, such as those required for rapid decision-making in HFT, are created by combining gates. Understanding logic gate usage is essential for optimizing FPGA designs for performance and resource utilization.

Understanding combinational and sequential logic

The distinction between combinational and sequential logic is crucial in FPGA programming. In combinational circuits, the output depends solely on current inputs, without regard to previous states. These circuits, implemented with logic gates, lack memory elements. Examples include adders and multiplexers, which are used extensively in HFT for fast data processing. In HDLs, combinational logic is described using concurrent statements.

Sequential logic involves circuits where the output depends on current inputs and previous states. These circuits use memory elements like flip-flops to store state information. In HDLs, sequential logic is usually described using clocked processes triggered by clock edges.

How do flip-flops and registers work in FPGAs?

Flip-flops and registers serve as basic memory elements. A flip-flop stores a single bit, typically changing state on a clock signal edge. FPGAs use flip-flops for sequential logic, maintaining state between clock cycles. The D flip-flop is most common, storing the input value (D) when triggered.

Registers, composed of multiple flip-flops, store multi-bit values. They are crucial for pipelining, data storage, and synchronization—all essential for the high-speed data processing in HFT. In HDL programming, synthesis tools infer flip-flops and registers from code structure. Variables assigned within a clocked process (VHDL) or an always block (Verilog) are usually implemented as registers. 

What are state machines and how to implement them?

State machines, or finite state machines (FSMs), are fundamental in digital design and FPGA programming. They model systems that exist in one of a finite number of states, with transitions triggered by inputs or conditions. The FSMs can be used to implement simple control logic, but also as a basis for more complex tasks like protocol parsing (such as optimized protocols like SBE - Simple Binary Encoding), feed handlers,  assembling order entry messages and implementing risk checks within an HFT system. FPGA state machines typically combine sequential logic (for state storage) and combinational logic (for next state and output logic).

 Implementation involves defining states, transitions, and outputs. In HDLs, state machines are often described using case statements within clocked processes. Registers store the current state, while combinational logic determines the next state and outputs. Best practices include using enumerated types for state representation and separating state registration from next-state logic.

FPGA Design Flow: From Concept to Implementation

The FPGA design flow transforms an idea into a functional implementation. It begins with high-level requirements and architectural planning. Designers then create a detailed design using HDLs, often employing a mix of behavioral, structural, and dataflow modeling. Testbenches are developed concurrently to verify functionality through simulation, a crucial step for validating HFT algorithms before deployment.

After the initial design, synthesis transforms the HDL code into a netlist of FPGA elements like LUTs and flip-flops. Implementation follows, including translation, mapping, placement, and routing. The synthesized design is fitted to the target FPGA's architecture. Timing analysis ensures performance requirements are met; if not, designers iterate or adjust settings. This iterative process is particularly important in HFT, where even nanosecond improvements can be significant. Optimization techniques may be applied throughout to improve performance, reduce resource use, or lower power consumption.