Hubbry Logo
Field-programmable gate arrayField-programmable gate arrayMain
Open search
Field-programmable gate array
Community hub
Field-programmable gate array
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Field-programmable gate array
Field-programmable gate array
Field-programmable gate array
View on Wikipedia
from Wikipedia

A Stratix IV FPGA from Altera
Spartan FPGA from Xilinx
Package
Die

A field-programmable gate array (FPGA) is a type of configurable integrated circuit that can be repeatedly programmed after manufacturing. FPGAs are a subset of logic devices referred to as programmable logic devices (PLDs). They consist of a grid-connected array of programmable logic blocks that can be configured "in the field" to interconnect with other logic blocks to perform various digital functions. FPGAs are often used in limited (low) quantity production of custom-made products, and in research and development, where the higher cost of individual FPGAs is not as important and where creating and manufacturing a custom circuit would not be feasible. Other applications for FPGAs include the telecommunications, automotive, aerospace, and industrial sectors, which benefit from their flexibility, high signal processing speed, and parallel processing abilities.

A FPGA configuration is generally written using a hardware description language (HDL) e.g. VHDL, similar to the ones used for application-specific integrated circuits (ASICs). Circuit diagrams were formerly used to write the configuration.

The logic blocks of an FPGA can be configured to perform complex combinational functions, or act as simple logic gates like AND and XOR. In most FPGAs, logic blocks also include memory elements, which may be simple flip-flops or more sophisticated blocks of memory.[1] Many FPGAs can be reprogrammed to implement different logic functions, allowing flexible reconfigurable computing as performed in computer software.

FPGAs also have a role in embedded system development due to their capability to start system software development simultaneously with hardware, enable system performance simulations at a very early phase of the development, and allow various system trials and design iterations before finalizing the system architecture.[2]

FPGAs are also commonly used during the development of ASICs to speed up the simulation process.

History

[edit]

The FPGA industry sprouted from programmable read-only memory (PROM) and programmable logic devices (PLDs). PROMs and PLDs both had the option of being programmed in batches in a factory or in the field (field-programmable).[3]

Altera was founded in 1983 and delivered the industry's first reprogrammable logic device in 1984 – the EP300 – which featured a quartz window in the package that allowed users to shine an ultra-violet lamp on the die to erase the EPROM cells that held the device configuration.[4]

Xilinx produced the first commercially viable field-programmable gate array in 1985[3] – the XC2064.[5] The XC2064 had programmable gates and programmable interconnects between gates, the beginnings of a new technology and market.[6] The XC2064 had 64 configurable logic blocks (CLBs), with two three-input lookup tables (LUTs).[7]

In 1987, the Naval Surface Warfare Center funded an experiment proposed by Steve Casselman to develop a computer that would implement 600,000 reprogrammable gates. Casselman was successful and a patent related to the system was issued in 1992.[3]

Altera and Xilinx continued unchallenged and quickly grew from 1985 to the mid-1990s when competitors sprouted up, eroding a significant portion of their market share. By 1993, Actel (later Microsemi, now Microchip) was serving about 18 percent of the market.[6]

The 1990s were a period of rapid growth for FPGAs, both in circuit sophistication and the volume of production. In the early 1990s, FPGAs were primarily used in telecommunications and networking. By the end of the decade, FPGAs found their way into consumer, automotive, and industrial applications.[8]

By 2013, Altera (31 percent), Xilinx (36 percent) and Actel (10 percent) together represented approximately 77 percent of the FPGA market.[9]

Companies like Microsoft have started to use FPGAs to accelerate high-performance, computationally intensive systems (like the data centers that operate their Bing search engine), due to the performance per watt advantage FPGAs deliver.[10] Microsoft began using FPGAs to accelerate Bing in 2014, and in 2018 began deploying FPGAs across other data center workloads for their Azure cloud computing platform.[11]

Since 2019, modern generation of FPGAs have been integrated with other architectures like AI engines to target workloads in artificial intelligence domain.[12]

Growth

[edit]

The following timelines indicate progress in different aspects of FPGA design.

Gates

[edit]
  • 1987: 9,000 gates, Xilinx[6]
  • 1992: 600,000, Naval Surface Warfare Department[3]
  • Early 2000s: millions[8]
  • 2013: 50 million, Xilinx[13]

Market size

[edit]
  • 1985: First commercial FPGA : Xilinx XC2064[5][6]
  • 1987: $14 million[6]
  • c. 1993: >$385 million[6][failed verification]
  • 2005: $1.9 billion[14]
  • 2010 estimates: $2.75 billion[14]
  • 2013: $5.4 billion[15]
  • 2020 estimate: $9.8 billion[15]
  • 2030 estimate: $23.34 billion[16]

Design starts

[edit]

A design start is a new custom design for implementation on an FPGA.

Design

[edit]

Contemporary FPGAs have ample logic gates and RAM blocks to implement complex digital computations. FPGAs can be used to implement any logical function that an ASIC can perform. The ability to update the functionality after shipping, partial re-configuration of a portion of the design[19] and the low non-recurring engineering costs relative to an ASIC design (notwithstanding the generally higher unit cost), offer advantages for many applications.[1]

As FPGA designs employ very fast I/O rates and bidirectional data buses, it becomes a challenge to verify correct timing of valid data within setup time and hold time.[20] Floor planning helps resource allocation within FPGAs to meet these timing constraints.

Some FPGAs have analog features in addition to digital functions. The most common analog feature is a programmable slew rate on each output pin. This allows the user to set low rates on lightly loaded pins that would otherwise ring or couple unacceptably, and to set higher rates on heavily loaded high-speed channels that would otherwise run too slowly.[21][22] Also common are quartz-crystal oscillator driver circuitry, on-chip RC oscillators, and phase-locked loops with embedded voltage-controlled oscillators used for clock generation and management as well as for high-speed serializer-deserializer (SERDES) transmit clocks and receiver clock recovery. Fairly common are differential comparators on input pins designed to be connected to differential signaling channels. A few mixed signal FPGAs have integrated peripheral analog-to-digital converters (ADCs) and digital-to-analog converters (DACs) with analog signal conditioning blocks, allowing them to operate as a system on a chip (SoC).[23] Such devices blur the line between an FPGA, which carries digital ones and zeros on its internal programmable interconnect fabric, and field-programmable analog array (FPAA), which carries analog values on its internal programmable interconnect fabric.

Logic blocks

[edit]
Main article: Logic block
Simplified example illustration of a logic cell (LUT – lookup table, FA – full adder, DFF – D-type flip-flop)

The most common FPGA architecture consists of an array of logic blocks called configurable logic blocks (CLBs) or logic array blocks (LABs) (depending on vendor), I/O pads, and routing channels.[1] Generally, all the routing channels have the same width (number of signals). Multiple I/O pads may fit into the height of one row or the width of one column in the array.

"An application circuit must be mapped into an FPGA with adequate resources. While the number of logic blocks and I/Os required is easily determined from the design, the number of routing channels needed may vary considerably even among designs with the same amount of logic. For example, a crossbar switch requires much more routing than a systolic array with the same gate count. Since unused routing channels increase the cost (and decrease the performance) of the FPGA without providing any benefit, FPGA manufacturers try to provide just enough channels so that most designs that will fit in terms of lookup tables (LUTs) and I/Os can be routed. This is determined by estimates such as those derived from Rent's rule or by experiments with existing designs."[24]

In general, a logic block consists of a few logical cells. A typical cell consists of a 4-input LUT, a full adder (FA) and a D-type flip-flop. The LUT might be split into two 3-input LUTs. In normal mode those are combined into a 4-input LUT through the first multiplexer (mux). In arithmetic mode, their outputs are fed to the adder. The selection of mode is programmed into the second mux. The output can be either synchronous or asynchronous, depending on the programming of the third mux. In practice, the entire adder or parts of it are stored as functions into the LUTs in order to save space.[25][26][27]

Hard blocks

[edit]

Modern FPGA families expand upon the above capabilities to include higher-level functionality fixed in silicon. Having these common functions embedded in the circuit reduces the area required and gives those functions increased performance compared to building them from logical primitives. Examples of these include multipliers, generic DSP blocks, embedded processors, high-speed I/O logic and embedded memories.

Higher-end FPGAs can contain high-speed multi-gigabit transceivers and hard IP cores such as processor cores, Ethernet medium access control units, PCI or PCI Express controllers, and external memory controllers. These cores exist alongside the programmable fabric, but they are built out of transistors instead of LUTs so they have ASIC-level performance and power consumption without consuming a significant amount of fabric resources, leaving more of the fabric free for the application-specific logic. The multi-gigabit transceivers also contain high-performance signal conditioning circuitry along with high-speed serializers and deserializers, components that cannot be built out of LUTs. Higher-level physical layer (PHY) functionality such as line coding may or may not be implemented alongside the serializers and deserializers in hard logic, depending on the FPGA.

Soft core

[edit]
A Xilinx Zynq-7000 all-programmable system on a chip

An alternate approach to using hard macro processors is to make use of soft processor IP cores that are implemented within the FPGA logic. Nios II, MicroBlaze and Mico32 are examples of popular softcore processors. Many modern FPGAs are programmed at run time, which has led to the idea of reconfigurable computing or reconfigurable systems – CPUs that reconfigure themselves to suit the task at hand. Additionally, new non-FPGA architectures are beginning to emerge. Software-configurable microprocessors such as the Stretch S5000 adopt a hybrid approach by providing an array of processor cores and FPGA-like programmable cores on the same chip.

Integration

[edit]

In 2012 the coarse-grained architectural approach was taken a step further by combining the logic blocks and interconnects of traditional FPGAs with embedded microprocessors and related peripherals to form a complete system on a programmable chip. Examples of such hybrid technologies can be found in the Xilinx Zynq-7000 all programmable SoC,[28] which includes a 1.0 GHz dual-core ARM Cortex-A9 MPCore processor embedded within the FPGA's logic fabric,[29] or in the Altera Arria V FPGA, which includes an 800 MHz dual-core ARM Cortex-A9 MPCore. The Atmel FPSLIC is another such device, which uses an AVR processor in combination with Atmel's programmable logic architecture. The Microsemi SmartFusion devices incorporate an ARM Cortex-M3 hard processor core (with up to 512 kB of flash and 64 kB of RAM) and analog peripherals such as a multi-channel analog-to-digital converters and digital-to-analog converters in their flash memory-based FPGA fabric.[citation needed]

Clocking

[edit]

Most of the logic inside of an FPGA is synchronous circuitry that requires a clock signal. FPGAs contain dedicated global and regional routing networks for clock and reset, typically implemented as an H tree, so they can be delivered with minimal skew. FPGAs may contain analog phase-locked loop or delay-locked loop components to synthesize new clock frequencies and manage jitter. Complex designs can use multiple clocks with different frequency and phase relationships, each forming separate clock domains. These clock signals can be generated locally by an oscillator or they can be recovered from a data stream. Care must be taken when building clock domain crossing circuitry to avoid metastability. Some FPGAs contain dual port RAM blocks that are capable of working with different clocks, aiding in the construction of building FIFOs and dual port buffers that bridge clock domains.

3D architectures

[edit]

To shrink the size and power consumption of FPGAs, vendors such as Tabula and Xilinx have introduced 3D or stacked architectures.[30][31] Following the introduction of its 28 nm 7-series FPGAs, Xilinx said that several of the highest-density parts in those FPGA product lines will be constructed using multiple dies in one package, employing technology developed for 3D construction and stacked-die assemblies.

Xilinx's approach stacks several (three or four) active FPGA dies side by side on a silicon interposer – a single piece of silicon that carries passive interconnect.[31][32] The multi-die construction also allows different parts of the FPGA to be created with different process technologies, as the process requirements are different between the FPGA fabric itself and the very high speed 28 Gbit/s serial transceivers. An FPGA built in this way is called a heterogeneous FPGA.[33]

Altera's heterogeneous approach involves using a single monolithic FPGA die and connecting other dies and technologies to the FPGA using Intel's embedded multi_die interconnect bridge (EMIB) technology.[34]

Programming

[edit]
Further information: Logic synthesis, Verification and validation, and Place and route

To define the behavior of the FPGA, the user provides a design in a hardware description language (HDL) or as a schematic design. The HDL form is more suited to work with large structures because it's possible to specify high-level functional behavior rather than drawing every piece by hand. However, schematic entry can allow for easier visualization of a design and its component modules.

Using an electronic design automation tool, a technology-mapped netlist is generated. The netlist can then be fit to the actual FPGA architecture using a process called place and route, usually performed by the FPGA company's proprietary place-and-route software. The user will validate the results using timing analysis, simulation, and other verification and validation techniques. Once the design and validation process is complete, the binary file generated, typically using the FPGA vendor's proprietary software, is used to (re-)configure the FPGA. This file is transferred to the FPGA via a serial interface (JTAG) or to an external memory device such as an EEPROM.

The most common HDLs are VHDL and Verilog. National Instruments' LabVIEW graphical programming language (sometimes referred to as G) has an FPGA add-in module available to target and program FPGA hardware. Verilog was created to simplify the process making HDL more robust and flexible. Verilog has a C-like syntax, unlike VHDL.[35][self-published source?]

To simplify the design of complex systems in FPGAs, there exist libraries of predefined complex functions and circuits that have been tested and optimized to speed up the design process. These predefined circuits are commonly called intellectual property (IP) cores, and are available from FPGA vendors and third-party IP suppliers. They are rarely free, and typically released under proprietary licenses. Other predefined circuits are available from developer communities such as OpenCores (typically released under free and open source licenses such as the GPL, BSD or similar license). Such designs are known as open-source hardware.

In a typical design flow, an FPGA application developer will simulate the design at multiple stages throughout the design process. Initially the RTL description in VHDL or Verilog is simulated by creating test benches to simulate the system and observe results. Then, after the synthesis engine has mapped the design to a netlist, the netlist is translated to a gate-level description where simulation is repeated to confirm the synthesis proceeded without errors. Finally, the design is laid out in the FPGA at which point propagation delay values can be back-annotated onto the netlist, and the simulation can be run again with these values.

More recently, OpenCL (Open Computing Language) is being used by programmers to take advantage of the performance and power efficiencies that FPGAs provide. OpenCL allows programmers to develop code in the C programming language.[36] For further information, see high-level synthesis and C to HDL.

Most FPGAs rely on an SRAM-based approach to be programmed. These FPGAs are in-system programmable and re-programmable, but require external boot devices. For example, flash memory or EEPROM devices may load contents into internal SRAM that controls routing and logic. The SRAM approach is based on CMOS.

Rarer alternatives to the SRAM approach include:

  • Fuse: one-time programmable. Bipolar. Obsolete.
  • Antifuse: one-time programmable. CMOS. Examples: Actel SX and Axcelerator families; Quicklogic Eclipse II family.[37]
  • PROM: programmable read-only memory technology. One-time programmable because of plastic packaging.[clarification needed] Obsolete.
  • EPROM: erasable programmable read-only memory technology. One-time programmable but with window, can be erased with ultraviolet (UV) light. CMOS. Obsolete.
  • EEPROM: electrically erasable programmable read-only memory technology. Can be erased, even in plastic packages. Some but not all EEPROM devices can be in-system programmed. CMOS.
  • Flash: flash-erase EPROM technology. Can be erased, even in plastic packages. Some but not all flash devices can be in-system programmed. Usually, a flash cell is smaller than an equivalent EEPROM cell and is, therefore, less expensive to manufacture. CMOS. Example: Actel ProASIC family.[37]

Manufacturers

[edit]

In 2016, long-time industry rivals Xilinx (now part of AMD) and Altera (now part of Intel) were the FPGA market leaders.[38] At that time, they controlled nearly 90 percent of the market.

Both Xilinx and Altera provide proprietary electronic design automation software for Windows and Linux (ISE/Vivado and Quartus) which enables engineers to design, analyze, simulate, and synthesize (compile) their designs.[39][40]

In March 2010, Tabula announced their FPGA technology that uses time-multiplexed logic and interconnect that claims potential cost savings for high-density applications.[41] On March 24, 2015, Tabula officially shut down.[42]

On June 1, 2015, Intel announced it would acquire Altera for approximately US$16.7 billion and completed the acquisition on December 30, 2015.[43]

On October 27, 2020, AMD announced it would acquire Xilinx[44] and completed the acquisition valued at about US$50 billion in February 2022.[45]

In February 2024 Altera became independent of Intel again.[46]

Other manufacturers include:

  • Achronix, manufacturing SRAM based FPGAs with 1.5 GHz fabric speed[47]
  • Altium, provides system-on-FPGA hardware-software design environment.[48]
  • Cologne Chip, German government-backed designer and producer of FPGAs[49]
  • Efinix offers small to medium-sized FPGAs. They combine logic and routing interconnects into a configurable XLR cell.[citation needed]
  • GOWIN Semiconductors, manufacturing small and medium-sized SRAM and flash-based FPGAs. They also offer pin-compatible replacements for a few Xilinx, Altera and Lattice products.[citation needed]
  • Lattice Semiconductor manufactures low-power SRAM-based FPGAs featuring integrated configuration flash, instant-on and live reconfiguration
  • Microchip:
  • QuickLogic manufactures ultra-low-power sensor hubs, extremely-low-powered, low-density SRAM-based FPGAs, with display bridges MIPI and RGB inputs; MIPI, RGB and LVDS outputs.[51]

Applications

[edit]
See also: Hardware acceleration

An FPGA can be used to solve any problem which is computable. FPGAs can be used to implement a soft microprocessor, such as the Xilinx MicroBlaze or Altera Nios II. But their advantage lies in that they are significantly faster for some applications because of their parallel nature and optimality in terms of the number of gates used for certain processes.[52]

FPGAs were originally introduced as competitors to complex programmable logic devices (CPLDs) to implement glue logic for printed circuit boards. As their size, capabilities, and speed increased, FPGAs took over additional functions to the point where some are now marketed as full systems on chips (SoCs). Particularly with the introduction of dedicated multipliers into FPGA architectures in the late 1990s, applications that had traditionally been the sole reserve of digital signal processors (DSPs) began to use FPGAs instead.[53][54]

The evolution of FPGAs has motivated an increase in the use of these devices, whose architecture allows the development of hardware solutions optimized for complex tasks, such as 3D MRI image segmentation, 3D discrete wavelet transform, tomographic image reconstruction, or PET/MRI systems.[55][56] The developed solutions can perform intensive computation tasks with parallel processing, are dynamically reprogrammable, and have a low cost, all while meeting the hard real-time requirements associated with medical imaging.

Another trend in the use of FPGAs is hardware acceleration, where one can use the FPGA to accelerate certain parts of an algorithm and share part of the computation between the FPGA and a general-purpose processor. The search engine Bing is noted for adopting FPGA acceleration for its search algorithm in 2014.[57] As of 2018, FPGAs are seeing increased use as AI accelerators including Microsoft's Project Catapult[11] and for accelerating artificial neural networks for machine learning applications.

Originally,[when?] FPGAs were reserved for specific vertical applications where the volume of production is small. For these low-volume applications, the premium that companies pay in hardware cost per unit for a programmable chip is more affordable than the development resources spent on creating an ASIC. Often a custom-made chip would be cheaper if made in larger quantities, but FPGAs may be chosen to quickly bring a product to market. By 2017, new cost and performance dynamics broadened the range of viable applications.[citation needed]

Other uses for FPGAs include:

Usage by United States military

[edit]

FPGAs play a crucial role in modern military communications, especially in systems like the Joint Tactical Radio System (JTRS) and in devices from companies such as Thales and Harris Corporation. Their flexibility and programmability make them ideal for military communications, offering customizable and secure signal processing. In the JTRS, used by the US military, FPGAs provide adaptability and real-time processing, crucial for meeting various communication standards and encryption methods.[64]

Security

[edit]

Concerning hardware security, FPGAs have both advantages and disadvantages as compared to ASICs or secure microprocessors. FPGAs' flexibility makes malicious modifications during fabrication a lower risk.[65] Previously, for many FPGAs, the design bitstream was exposed while the FPGA loads it from external memory, typically during powerup. All major FPGA vendors now offer a spectrum of security solutions to designers such as bitstream encryption and authentication. For example, Altera and Xilinx offer AES encryption (up to 256-bit) for bitstreams stored in an external flash memory. Physical unclonable functions (PUFs) are integrated circuits that have their own unique signatures and can be used to secure FPGAs while taking up very little hardware space.[66]

FPGAs that store their configuration internally in nonvolatile flash memory, such as Microsemi's ProAsic 3 or Lattice's XP2 programmable devices, do not expose the bitstream and do not need encryption. Customers wanting a higher guarantee of tamper resistance can use write-once, antifuse FPGAs from vendors such as Microsemi.

With its Stratix 10 FPGAs and SoCs, Altera introduced a Secure Device Manager and physical unclonable functions to provide high levels of protection against physical attacks.[67]

In 2012 researchers Sergei Skorobogatov and Christopher Woods demonstrated that some FPGAs can be vulnerable to hostile intent. They discovered a critical backdoor vulnerability had been manufactured in silicon as part of the Actel/Microsemi ProAsic 3 making it vulnerable on many levels such as reprogramming crypto and access keys, accessing unencrypted bitstream, modifying low-level silicon features, and extracting configuration data.[68]

In 2020 a critical vulnerability (named Starbleed) was discovered in all Xilinx 7 series FPGAs that rendered bitstream encryption useless. There is no workaround. Xilinx did not produce a hardware revision. Ultrascale and later devices, already on the market at the time, were not affected.[citation needed]

Similar technologies

[edit]

Historically, FPGAs have been slower, less energy efficient and generally achieved less functionality than their fixed ASIC counterparts. A study from 2006 showed that designs implemented on FPGAs need on average 40 times as much area, draw 12 times as much dynamic power, and run at one third the speed of corresponding ASIC implementations.[69]

Advantages of FPGAs include the ability to reprogram equipment in the field to fix bugs or make other improvements. Some FPGAs have the capability of partial re-configuration that lets one portion of the device be re-programmed while other portions continue running.[70][71] Other advantages may include shorter time to market and lower non-recurring engineering costs. Vendors can also take a middle road via FPGA prototyping: developing their prototype hardware on FPGAs, but manufacturing their final version as an ASIC after the design has been committed. This is often also the case with new processor designs.[72]

The primary differences between CPLDs and FPGAs are architectural. A CPLD has a comparatively restrictive structure consisting of one or more programmable sum-of-products logic arrays feeding a relatively small number of clocked registers. As a result, CPLDs are less flexible but have the advantage of more predictable propagation delay. FPGA architectures, on the other hand, are dominated by interconnect. This makes them far more flexible but also far more complex to design for, or at least requiring more complex electronic design automation (EDA) software. Another distinction between FPGAs and CPLDs is one of size, as FPGAs are usually much larger in terms of resources than CPLDs. Typically only FPGAs contain more complex embedded functions such as adders, multipliers, memory, and serializer/deserializers. Another common distinction is that CPLDs contain embedded flash memory to store their configuration, while FPGAs typically store their configuration in SRAM and require external non-volatile memory to initialize it on powerup. When a design requires simple instant-on, CPLDs are generally preferred. Sometimes both CPLDs and FPGAs are used in a single system design. In those designs, CPLDs generally perform glue logic functions.[73]

See also

[edit]

References

[edit]

Further reading

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Field-programmable gate array

View on Grokipedia
from Grokipedia
A field-programmable gate array (FPGA) is a reconfigurable designed to be programmed by a user after manufacturing to implement custom digital logic functions. Unlike fixed-function application-specific integrated circuits (ASICs), FPGAs allow for post-production modifications through hardware description languages (HDLs) like or , enabling flexibility in design and deployment. The concept of configurable computing, which underpins FPGAs, was proposed in the 1960s, but the first commercially available FPGA was introduced by in 1985 with the XC2000 series, featuring lookup tables (LUTs) and D flip-flops (DFFs). Subsequent milestones include the 1991 Xilinx XC4000, which added carry chains and LUT-based RAM; the 1995 Altera FLEX series with dual-port block RAM; and the 2000 Virtex-2, introducing embedded multipliers. By the 2010s, FPGAs had evolved into third-generation devices with millions of logic cells, supporting (HLS) tools and adaptive computing architectures like 's 2019 ACAP. This progression has been driven by , doubling logic density roughly every 18 months since the . At their core, FPGAs consist of an array of configurable logic blocks (CLBs), programmable interconnects, , embedded memory (block RAM), and specialized . CLBs typically include LUTs for implementing combinatorial logic and flip-flops for sequential operations, while interconnects route signals between blocks via multiplexers and programmable points. Modern FPGAs also integrate microprocessors in system-on-chip (SoC) variants, phase-locked loops (PLLs) for , and high-speed transceivers for interfacing. Configuration is achieved by loading a bitstream into on-chip memory, often SRAM-based, allowing for rapid reconfiguration. FPGAs excel in applications requiring parallelism, low latency, and customization, such as , , bioinformatics, systems, and acceleration. They offer advantages over general-purpose processors by implementing dedicated hardware pipelines for tasks like data logging or acceleration, reducing power consumption and improving reliability in hardware-timed environments. In high-end uses, such as ASIC emulation and supercomputing, FPGAs support up to 18.5 million logic cells and thousands of DSP blocks (as of 2023), making them ideal for prototyping and evolving workloads.

History

Invention and Early Development

The concept of field-programmable gate arrays (FPGAs) emerged from earlier programmable logic devices (PLDs) developed in the late , such as (PAL) and field-programmable logic arrays (FPLA), which utilized PROM-based fusible links for custom logic implementation. These devices, pioneered by Monolithic Memories Inc. (MMI), offered a step beyond fixed TTL logic by allowing users to program AND/OR arrays for prototyping, but they were limited to simple combinational functions without extensive interconnectivity. In the , during the burgeoning very-large-scale integration (VLSI) era, engineers sought alternatives to costly custom integrated circuits (ICs), as the shift from small-scale to high-density chips increased design complexity and non-recurring engineering expenses for application-specific integrated circuits (). Ross Freeman, an engineer at , conceived the idea of a reprogrammable logic array in the mid-1970s, filing initial applications for a device with configurable gates and interconnects that could be field-programmed multiple times without fabrication. Freeman, along with Bernard Vonderschmitt and James Barnett, founded in February 1984 to commercialize this vision, aiming to bridge the gap between and production hardware amid the VLSI boom. Their breakthrough culminated in the invention of the first FPGA in 1984, patented as a configurable electrical circuit with variably interconnected logic elements controlled by memory cells. Xilinx released the XC2064, the world's first commercial FPGA, in November 1985, featuring 64 configurable logic blocks (CLBs) equivalent to approximately 1,000 to 1,500 gates and fabricated in a 1.2-micron process. This device allowed users to program logic functions and routing in the field using electrical signals, reducing dependency on mask-programmed . Early FPGAs like the XC2064 faced significant challenges, including high unit costs—often 10 times that of equivalent —and limited gate counts that restricted them to small-scale applications, making adoption slow outside niche prototyping. By the early 1990s, FPGAs began gaining traction in for flexible and networking equipment, where reprogrammability supported evolving standards without full redesigns. This initial marked a pivotal shift from custom IC dominance, enabling faster time-to-market despite ongoing cost and density limitations.

Technological Evolution and Market Growth

The technological evolution of field-programmable gate arrays (FPGAs) has been marked by exponential increases in logic density, driven by semiconductor process advancements and architectural refinements. In the 1980s, early commercial FPGAs, such as Xilinx's XC2064 introduced in 1985, offered densities equivalent to thousands of logic gates, limited by 1.2 μm process technology and basic configurable logic blocks. By the late 1990s and early 2000s, densities surged into the millions of system gates; for instance, the Xilinx Virtex-E family, released in 1999, scaled up to 4 million system gates using a 0.18 μm process, while the Virtex-II series in 2001 reached up to 10 million system gates on a 150 nm node. This growth continued through the 2010s and into the 2020s, with modern FPGAs leveraging sub-10 nm processes—such as 7 nm in AMD's Versal Premium series announced in 2020—enabling densities exceeding billions of transistors and supporting complex applications like AI acceleration. Key innovations have paralleled these density gains, enhancing reprogrammability and performance. The widespread adoption of SRAM-based configuration in the 1990s, exemplified by Xilinx's XC4000 family launched in 1990, allowed for volatile but fast in-system reconfiguration, replacing earlier PROM and antifuse technologies and enabling iterative design prototyping. In the early , integration of specialized blocks further advanced capabilities: Xilinx's Virtex-II Pro in 2002 introduced dedicated DSP slices for efficient , while block RAM (BRAM) modules, first embedded in the original Virtex family in 1998, provided on-chip memory up to several megabits to reduce external dependencies. Entering the , 3D stacking and chiplet-based designs emerged as pivotal developments; AMD's Stacked Interconnect (SSI) , refined in the Virtex UltraScale+ series around 2016 and expanded in Versal adaptive compute acceleration platforms (ACAPs) by 2020, enables modular multi-die integration for higher bandwidth and scalability, akin to chiplet architectures in . Following the 2022 acquisition, AMD continued advancing FPGA , releasing the Versal AI Edge Gen 2 in 2024 on a 5nm process, enhancing AI capabilities at the edge. Market growth has reflected these technological strides, transforming FPGAs from niche prototyping tools to essential components in diverse industries. The global FPGA market reached approximately $1 billion by 2000, fueled by adoption in and defense for rapid ASIC emulation, where FPGAs' reprogrammability significantly lowered non-recurring engineering (NRE) costs compared to custom silicon development, which could exceed millions per project. By 2020, the market had expanded to nearly $10 billion, driven by demand in data centers, automotive, and infrastructure, with projections estimating $9.9 billion for that year. As of 2025, the global FPGA market is estimated at around $11 billion, continuing growth driven by AI and adaptive demands. A key enabler has been the reduced NRE barrier, allowing startups and enterprises to complex systems on FPGAs before committing to ASIC production, thereby accelerating time-to-market. Industry shifts in the and underscore FPGA maturation, with consolidation among leaders and democratization via open-source ecosystems. Intel's $16.7 billion acquisition of Altera in 2015 integrated FPGA expertise into its CPU portfolio, enhancing hybrid CPU-FPGA offerings for datacenter acceleration. Similarly, AMD's $35 billion all-stock acquisition of Xilinx in , completed in , combined FPGA leadership with x86 and GPU technologies to target AI and markets. Concurrently, the rise of open-source tools in the , notably the Yosys Open SYnthesis Suite launched in , has lowered entry barriers by providing free alternatives to flows, supporting synthesis for various FPGA architectures and fostering innovation in academic and hobbyist communities.

Fundamentals

Definition and Basic Principles

A field-programmable gate array (FPGA) is an integrated circuit designed to be configured by a customer or designer after manufacturing to implement custom digital logic functions through an array of programmable logic blocks interconnected by programmable routing resources. This post-fabrication configurability distinguishes FPGAs from mask-programmed devices like application-specific integrated circuits (ASICs), enabling users to adapt the hardware for specific applications without requiring new silicon fabrication. The core operating principle of an FPGA relies on reconfigurability via configuration memory, typically implemented using (SRAM) cells that store configuration bits to control the behavior of logic elements and interconnects. These bits program multiplexers and other elements to route signals and define logic operations, allowing the FPGA to emulate diverse digital circuits from simple to complex systems. Central to FPGA logic implementation are lookup tables (LUTs), small memory arrays that realize any combinational logic function by storing precomputed output values for all possible input combinations. For instance, a 4-input LUT operates as a 16-bit read-only memory (ROM), where the inputs serve as address lines to select the appropriate output bit, enabling the emulation of any Boolean function of four variables without dedicated gate structures. LUTs are paired with flip-flops in configurable logic blocks to support both combinational and sequential logic, providing the foundational building blocks for user-defined designs. A key advanced concept in FPGA operation is partial reconfiguration, which permits dynamic modification of specific logic regions during runtime without interrupting or resetting the entire device. This feature leverages the modular architecture to swap functionality in targeted areas, supporting applications requiring adaptability such as real-time system updates. In terms of operational flow, an FPGA initializes upon power-on by loading a from external into its SRAM-based configuration cells, thereby instantiating the desired hardware behavior. The bitstream is derived from user-specified hardware descriptions authored in hardware description languages (HDLs) like or , which undergo synthesis, placement, and routing in (EDA) tools to generate the final configuration file.

Comparison to Fixed Hardware

Field-programmable gate arrays (FPGAs) differ significantly from application-specific integrated circuits () in development timelines and costs. FPGAs enable a shorter time-to-market, often achievable in months through reconfiguration without fabrication, in contrast to , which typically require 12 to 24 months for design, verification, and manufacturing. Additionally, FPGAs incur no (NRE) costs, avoiding the multimillion-dollar expenses associated with ASIC mask sets and prototyping, making them ideal for risk-averse projects. However, offer superior unit at high volumes due to their fixed, optimized structure, while FPGAs carry higher per-unit costs from programmable overhead. In terms of performance and , generally outperform FPGAs by a factor of about 2 to 4 times in clock , stemming from the routing and logic overhead in programmable fabrics that reduces clock speeds and increases latency. This gap arises because FPGAs must accommodate general interconnects, whereas employ direct, customized wiring for specific functions. Power consumption follows a similar trend, with achieving higher through tailored transistors and minimal leakage, though the disparity has narrowed in modern nodes (e.g., 7 nm and below) as FPGAs incorporate advanced FinFETs and specialized blocks to approach ASIC-like . As of 2025, continued advancements in FPGA , including sub-5 nm nodes and optimized architectures, have further narrowed this gap in many applications. Compared to microprocessors and microcontrollers, FPGAs excel in parallel for compute-intensive tasks such as (DSP), where sequential instruction execution on CPUs limits throughput. For instance, FPGAs can implement custom arithmetic logic units (ALUs) tailored to specific algorithms, processing multiple data streams concurrently without the overhead of general-purpose instruction sets, achieving orders-of-magnitude speedups over software implementations on microcontrollers. This parallelism suits applications requiring real-time filtering or transforms, offloading the host processor to enhance overall system responsiveness. FPGAs also provide advantages over graphics processing units (GPUs) in scenarios demanding low-latency, fixed-function acceleration, such as processing. In low-density parity-check (LDPC) decoding for , FPGA implementations deliver latencies as low as 61.65 μs, outperforming GPU equivalents at 87 μs, due to deterministic hardware pipelines and fine-grained control over flow. However, FPGAs are less inherently suited for floating-point-intensive workloads like certain AI inferences without embedded hard IP blocks for multipliers and accumulators, where GPUs leverage massive parallel cores optimized for such operations. Key decision factors for selecting FPGAs over fixed hardware revolve around production volume and flexibility needs. High-volume manufacturing favors for cost amortization, while low-volume runs, prototyping, or evolving standards benefit from FPGAs' reprogrammability and zero NRE. Hybrid solutions, such as system-on-chip (SoC) FPGAs like Xilinx's Zynq UltraScale+ MPSoC, integrate hard processor systems with programmable logic to blend the parallelism of FPGAs with the software ecosystem of microprocessors, offering a balanced alternative for embedded applications.

Architecture

Logic and Programmable Blocks

The core of an FPGA's reconfigurable logic fabric consists of configurable logic blocks (CLBs), which serve as the fundamental units for implementing combinational and sequential digital circuits. Each CLB typically integrates multiple lookup tables (LUTs) for function generation, flip-flops for storage, and internal multiplexers for signal routing within the block, enabling flexible mapping of user-defined logic. In architectures like those from (formerly ), a CLB is subdivided into slices, with each slice containing four 6-input LUTs and eight flip-flops, allowing the block to support a variety of modes including via LUTs, through flip-flop registration, and arithmetic operations using dedicated carry chains. A 6-input LUT can realize any of 64 possible functions by storing the in its memory, while the flip-flops provide synchronous storage with options for clock enable and reset. Internal multiplexers, such as 7-input and 8-input variants, facilitate mode selection and output combining within the slice. In contrast, Intel's FPGAs employ adaptive logic modules () as the basic elements, grouped into logic array blocks (LABs); each ALM features an 8-input fracturable LUT paired with four registers and two dedicated adders, capable of implementing select 7-input functions, all 6-input functions, or two independent smaller LUTs (e.g., 4-input each) to optimize density. Function generation in these blocks relies on LUTs as versatile implementations, where the LUT's SRAM configuration defines the output for each input combination, enabling rapid synthesis of arbitrary logic without custom wiring. For arithmetic functions, dedicated carry logic enhances efficiency; in designs, a 4-bit ripple-carry per slice uses multiplexers (MUXCY) and exclusive-OR gates to propagate carries, with chains extending across multiple CLBs for wider operations like adders or counters. similarly incorporate embedded adders within the fracturable LUT structure to support fast arithmetic without additional resources. Modern FPGAs achieve high logic density through scaling these blocks, with devices featuring over 1 million LUTs or equivalent elements; for instance, AMD's Versal Premium Gen 2 series offers up to 3.27 million system logic cells, while Intel's Stratix 10 reaches 933,120 . Equivalent gate count is a rough, vendor-specific metric; a 6-input LUT is often estimated at 20-30 equivalent gates, so 1 million LUTs approximate 20-30 million gates.

Interconnect and Routing Resources

The interconnect and routing resources in a field-programmable gate array (FPGA) form a programmable wiring network that connects configurable logic blocks, enabling flexible signal paths across the device. This network typically consists of horizontal and vertical channels surrounding an array of logic blocks, with wires segmented into various lengths to balance routability, area, and delay. Short segments facilitate local connections, while longer segments support global with reduced switch overhead. In island-style architectures, common in commercial FPGAs, this structure occupies 80-90% of the total chip area, underscoring its dominance in . The routing hierarchy relies on connection blocks and switch boxes to interface logic blocks with the channel wires. Connection blocks provide access from logic block pins to the routing channels, with flexibility FcF_c defined as the fraction of channel tracks accessible per pin (e.g., Fc=0.5F_c = 0.5 allows connection to half the tracks). Switch boxes, located at channel intersections, enable turns and continuations between horizontal and vertical wires, characterized by flexibility FsF_s as the number of outgoing connections per incoming wire (e.g., Fs=3F_s = 3). Segmented wires in the channels include short (spanning one logic block), medium (two to four blocks), and long lines (spanning many blocks for low-skew global signals), allowing efficient path formation while minimizing switch usage for distant connections. Switch matrices within these blocks are implemented using multiplexers controlled by configuration bits, such as 10:1 or 20:1 multiplexers at intersections to select signal paths. Pass-transistor switches, often NMOS-based with transmission gates, offer compact area but suffer from resistance degradation over multiple hops, impacting . Buffer-based alternatives, employing tri-state inverters or full buffers, maintain drive strength for longer wires but increase area and power; modern FPGAs blend both, with buffers driving longer segments to optimize performance. Routing challenges arise from limited resources, particularly congestion where multiple nets compete for tracks, potentially leading to unroutable designs. Place-and-route tools address this through iterative algorithms like rip-up and retry, where existing routes are torn up in congested areas and rerouted with penalty costs on overuse to promote balanced channel utilization. Channel width, defined as the number of tracks per channel (typically 100-200 in modern devices, though varying by architecture), must be sufficient to accommodate all nets without overflow; insufficient width increases critical path delays by forcing detours. Performance is significantly influenced by , with delays often comprising 50-70% of the critical path due to wire and resistance, far exceeding logic block contributions. This dominance stems from the programmable nature of interconnects, which introduce extra parasitics compared to fixed . Wire delay can be approximated using the Elmore model: tdelay≈R×C×lengtht_{\text{delay}} \approx R \times C \times \text{length} where RR and CC are resistance and per unit length, highlighting the linear scaling with path length and the need for segmentation to mitigate long-route penalties.

Input/Output and Clocking Systems

Input/Output Blocks (IOBs) in FPGAs serve as programmable interfaces that manage bidirectional data flow between external pins and the internal logic fabric, supporting a wide range of electrical standards to ensure compatibility with diverse systems. These blocks typically accommodate differential signaling protocols such as LVDS for high-speed data transmission and PCIe interfaces up to Generation 5, enabling data rates of 32 GT/s per lane in modern implementations. Additionally, IOBs feature configurable options including weak pull-up or pull-down resistors to stabilize unconnected inputs and programmable slew rate control on outputs to optimize signal integrity and reduce electromagnetic interference. For high-speed applications, integrated transceivers within IOBs, such as Serializer/Deserializer (SerDes) units, operate at rates up to 28 Gbps, facilitating protocols like 100G Ethernet. Clocking resources in FPGAs include dedicated global clock networks designed to distribute timing signals across the device with minimal variation, typically supporting 32 or more dedicated clock lines to handle multiple independent domains. These networks achieve low skew, often below 100 ps peak-to-peak, ensuring synchronized operation of logic elements over large die areas. Phase-Locked Loops (PLLs) and Digital Clock Managers (DCMs), now evolved into Mixed-Mode Clock Managers (MMCMs) in advanced architectures, provide frequency synthesis capabilities, such as multiplying an input clock of 100 MHz to 500 MHz through programmable multiplication factors while allowing phase adjustments for alignment. Clock management systems employ dedicated routing paths to propagate clocks with low , typically under 1 ps RMS for critical paths, minimizing timing uncertainties in high-performance designs. Dynamic phase shifting within PLLs or MMCMs enables real-time adjustments to clock edges, which is essential for interfacing with DDR memory where data strobe (DQS) signals must align precisely with (DQ) lines to capture information correctly. In integration examples, Multi-Gigabit Transceivers (MGTs) incorporate embedded equalization techniques, such as adaptive continuous-time linear equalizers, to compensate for signal degradation over long traces or backplanes at multi-Gbps speeds. Modern FPGAs often provide over 1,000 user I/O pins, allowing extensive external connectivity in applications requiring high pin counts.

Embedded Hard IP Blocks

Embedded hard IP blocks in field-programmable gate arrays (FPGAs) are fixed-function hardware macros fabricated directly into the die to accelerate common operations with superior performance, power efficiency, and resource utilization compared to implementing equivalent functionality using programmable logic. These blocks include dedicated arrays, units, and interface controllers, enabling FPGAs to handle data-intensive tasks like buffering, arithmetic computations, and high-speed communication without consuming configurable resources. By integrating these specialized circuits, FPGA designers can achieve higher throughput in applications such as , networking, and embedded systems, while the surrounding programmable fabric provides customization around these fixed elements. Block RAM (BRAM) consists of dual-port (SRAM) arrays optimized for on-chip data storage and buffering in FPGAs. Each BRAM block typically provides 36 Kb of capacity, configurable as a single 36 Kb unit or two independent 18 Kb units, with two independent read/write ports supporting simultaneous access from different clock domains. These blocks support true dual-port operation, where both ports can perform read or write actions concurrently, and simple dual-port modes for asymmetric read/write configurations; they are also programmable as first-in-first-out (FIFO) buffers with built-in FIFO logic for queue management in pipelines. In high-end devices, such as AMD's Virtex UltraScale+ FPGAs, the aggregate BRAM capacity can reach up to approximately 75 Mb, enabling efficient handling of large datasets in applications like image processing or inference without external memory access. Digital signal processing (DSP) slices are dedicated arithmetic units designed for high-speed multiply-accumulate (MAC) operations and other numerical computations prevalent in filtering, , and transform algorithms. Each DSP slice features a 25x18-bit multiplier, a 48-bit post-adder/accumulator, an optional 18-bit pre-adder for input conditioning, and configurable registers to support multi-cycle operations at s up to 550 MHz. These elements enable efficient implementation of MAC functions, where the pre-adder sums inputs before to reduce slice count in symmetric filters, and the stages minimize latency while maximizing throughput. The overall computational capacity can be estimated as operations per second = × number of slices × effective parallelism per slice; for instance, in AMD's Kintex UltraScale FPGAs with over 2,000 slices operating at 500 MHz and supporting dual multiplies per cycle, this yields peak performance approaching 1 TFLOPS for fixed-point operations in compute-intensive workloads. Beyond memory and arithmetic blocks, FPGAs incorporate other specialized hard IP for interfacing and processing, such as Ethernet media access controllers (MACs), (PCIe) endpoints, and embedded processor cores in system-on-chip (SoC) variants. Ethernet MACs provide hardened support for standards like 10/100/1000 Mbps or up to 100 Gbps, including frame processing and checksum offload to reduce logic overhead in networking applications; for example, AMD's Zynq UltraScale+ devices integrate 100G Ethernet blocks compliant with IEEE 802.3. endpoints handle high-bandwidth data transfer with integrated PHY, data link, and transaction layers, supporting Gen3 (8 GT/s) or Gen4 (16 GT/s) rates, as seen in Intel's Stratix 10 FPGAs with up to 16 lanes per block. In SoC-FPGAs, hard processor systems (HPS) embed ARM Cortex cores for software-defined control; AMD's Zynq-7000 series features dual Cortex-A9 cores at up to 1 GHz with SIMD extensions, while Intel's Stratix 10 SX includes a quad-core Cortex-A53 at 1.5 GHz for hybrid CPU-FPGA acceleration. The primary trade-off of embedded hard IP blocks is their fixed , which delivers up to 10 times higher logic density and improved power compared to soft IP implementations synthesized from configurable logic, but at the cost of reduced reconfigurability for non-standard functions. For instance, in AMD's UltraScale , hard DSP slices achieve 2-3x better than equivalent soft multipliers due to optimized layout, while in Intel's Stratix 10, integrated PCIe hard IP reduces resource utilization by over 50% versus soft cores, though customization is limited to parameterizable features like lane width. This balance makes hard blocks essential for performance-critical paths in production designs, with programmable logic handling surrounding adaptability.

Advanced Architectural Features

Modern field-programmable gate arrays (FPGAs) have evolved to incorporate system-on-chip (SoC) integrations that combine programmable logic fabric with embedded processors and peripherals, enabling platforms capable of handling diverse workloads efficiently. For instance, 's Zynq UltraScale+ MPSoC family integrates a quad-core application processing unit, dual-core ARM Cortex-R5F real-time processing unit, and a Mali-400 MP2 alongside the FPGA fabric, facilitating seamless coordination between software-defined processing and for applications like embedded vision and automotive systems. These SoC-FPGAs support heterogeneous architectures where CPUs, GPUs, and FPGAs operate in tandem, optimizing power efficiency and performance by assigning tasks to the most suitable compute element, as seen in platforms that leverage FPGA reconfigurability for analytics and . Advancements in three-dimensional (3D) architectures further enhance FPGA capabilities by stacking silicon dies to increase density and reduce interconnect delays. Through-silicon vias (TSVs) serve as vertical interconnects in these stacked structures, enabling direct inter-layer communication that minimizes signal propagation latency compared to traditional two-dimensional routing. AMD's Stacked Silicon Interconnect (SSI) technology, for example, allows multiple FPGA dies to be integrated with lower latency and power consumption, supporting high-bandwidth memory (HBM) stacks in devices like the Virtex UltraScale+ series. Monolithic 3D integrated circuits (ICs) and hybrid stacking approaches, such as those explored in research prototypes, can achieve up to 50% latency reductions in critical paths by shortening wire lengths, while also improving overall throughput for compute-intensive tasks. Intel's Stratix 10 FPGAs, meanwhile, integrate support for memory via high-speed interfaces like PCIe 4.0, allowing FPGAs to leverage persistent, low-latency storage in accelerated systems without full die stacking. Emerging trends in FPGA design emphasize chiplet-based architectures and adaptive tailored for (AI). AMD's Versal AI Edge series, introduced in 2023, employs modular tiles including AI Engine tiles for scalar, vector, and tensor processing, enabling dynamic reconfiguration to optimize inference workloads in edge devices like autonomous vehicles and industrial automation. These designs break monolithic structures into specialized interconnect, compute, and I/O tiles, improving yield, scalability, and performance; for example, next-generation Versal FPGAs like the VP1902 achieve up to 18.5 million system logic cells, more than doubling the density of prior monolithic implementations. In adaptive AI , FPGA fabrics incorporate dynamic tensor units, such as systolic array-based "Tensor Slices," which replace portions of programmable logic to accelerate operations like convolutions, offering flexibility for evolving architectures without full redesigns. As of 2024, AMD's Versal Gen 2 series, including Premium Gen 2 devices with up to 3.27 million system logic cells and support for PCIe 6.0 and CXL 3.1, further advances integration and performance. Looking toward future directions, FPGA architectures are exploring optical interconnects and quantum-inspired reconfigurability to address bandwidth and computational limits in exascale systems. Photonic integration promises to replace electrical interconnects with light-based links, reducing power dissipation and enabling terabit-per-second data rates for AI and , as demonstrated in prototypes combining with FPGA controllers. Quantum-inspired approaches, meanwhile, leverage FPGA reconfigurability to emulate quantum hardware behaviors, such as dynamic partial reconfiguration for simulating operations or error correction, paving the way for hybrid classical-quantum accelerators in scalable platforms. These innovations, still in early research phases, aim to extend FPGA versatility into domains requiring ultra-low latency and probabilistic paradigms.

Configuration and Programming

Configuration Memory Technologies

The configuration memory in field-programmable gate arrays (FPGAs) stores the bitstream that programs the device's logic, , and other resources, determining its functionality after fabrication. Different memory technologies offer trade-offs in volatility, reconfiguration speed, power efficiency, , and environmental resilience, influencing their adoption in various applications from to space systems. SRAM-based memories dominate due to their reprogrammability, while non-volatile options like and Flash prioritize reliability and low power, and emerging types like FRAM and MRAM address limitations in and harsh conditions. SRAM-based configuration is volatile and widely used in over 60% of FPGAs as of 2024, particularly in high-density devices from () and . Upon power-off or reset, the loses its contents, requiring reloading of the from external non-volatile storage such as Flash or during initialization, which typically takes milliseconds (e.g., over 200 ms for a Spartan-3 XC3S200). This technology enables rapid in-system reconfiguration in tens of milliseconds but consumes more power due to the need for external devices and clears automatically on , making it suitable for prototyping and applications tolerant of startup delays. Antifuse-based memory is non-volatile and one-time programmable (OTP), forming permanent connections via metal-oxide breakdown during programming, which provides inherent design security and eliminates the need for external configuration storage. Employed in Microchip's (formerly ) ProASIC and RTG4 series for radiation-hardened space applications, it achieves near-instant power-up times of about 60 µs and offers high reliability with no reconfiguration capability post-programming. This technology excels in fixed-function, high-security environments like but lacks flexibility for iterative designs due to its OTP nature. Flash and EEPROM-based memories are non-volatile with multi-time programmability, supporting 100 to 10,000 erase/write cycles depending on the , and integrate configuration storage directly on-chip for simplified designs and low power. Lattice Semiconductor's iCE40 and MachXO2 families use embedded Flash for low-power embedded systems, enabling reconfiguration in microseconds (around 50 µs) and internal booting without external memory. Microchip's ProASIC3 series leverages Flash for space-grade FPGAs, consuming roughly one-third the power of SRAM equivalents while providing reprogrammability and tolerance of 25 to 30 krad(Si). These are favored in battery-powered or size-constrained applications requiring occasional updates. Emerging non-volatile technologies like FRAM (ferroelectric RAM) and (magnetoresistive RAM) aim to combine instant-on capability, unlimited endurance, and robustness for demanding environments. FRAM offers low-power operation (similar to SRAM but non-volatile) and high radiation hardness, with densities up to 2 Mb suitable for booting space-grade FPGAs and processors, making it attractive for low-earth orbit missions where SEU immunity and minimal power draw are critical. , using magnetic tunnel junctions, provides superior endurance (over 10^15 cycles in some variants), faster configuration (e.g., x8 widths at 160 MHz), and resilience to extreme temperatures and radiation, as integrated in Lattice's Certus-NX and Avant FPGAs with Everspin partners. These technologies trade higher initial costs for overcoming Flash's endurance limits and SRAM's volatility, targeting edge AI, automotive, and sectors.

Programming Process and Tools

The programming process for an FPGA begins with the synthesis of a (HDL) design into a gate-level , followed by place-and-route implementation to map the logic onto the device's resources, culminating in the generation of a file that encodes the configuration data. This is then downloaded to the FPGA, typically via interfaces such as for debugging and initial programming or SPI for high-speed configuration from external . JTAG download speeds can reach up to 25 Mbps depending on the cable and device, while SPI modes, particularly quad-SPI, enable rates up to approximately 100 MB/s in modern devices like Intel Stratix 10 FPGAs. Partial reconfiguration allows dynamic updates to specific regions of the FPGA fabric without halting the entire device, enabling efficient resource reuse in applications requiring adaptability. For instance, swapping 10% of the fabric might take on the order of milliseconds to seconds, depending on the bitstream size and interface speed, as reconfiguration overhead scales with the modified area. This process involves loading partial s through the internal configuration access port (ICAP) or external interfaces, with tools managing region isolation to prevent glitches during updates. Vendor-specific tools streamline this , integrating synthesis, , , and generation. AMD's Design Suite handles HDL synthesis to produce optimized netlists, performs placement and routing for timing closure, and supports behavioral, post-synthesis, and post- simulations to verify functionality before programming. Similarly, Intel's Quartus Prime software compiles designs through synthesis and fitting stages, generating while integrating with for comprehensive , including waveform viewing and testbench modifications during the design flow. The open-source ecosystem has grown significantly since 2015, providing alternatives to proprietary tools for greater accessibility and customization. Tools like nextpnr serve as a timing-driven place-and-route , supporting devices such as Lattice iCE40, ECP5, and experimental architectures when paired with Yosys for synthesis, enabling full generation without . The SymbiFlow project, initiated around 2018 as part of broader efforts to create a fully open toolchain, extends this by targeting commercial FPGAs like 7-series through data-driven flows for synthesis, placement, and . FPGA boot modes determine how the is loaded at , loading configuration into SRAM-based for operation. Master serial mode (mode pins 000) has the FPGA generate the configuration clock (CCLK) and read from an external at 1-bit width, while slave serial mode (111) relies on an external clock source for daisy-chaining multiple devices. Parallel flash mode, or master BPI (010), interfaces with NOR flash at 8- or 16-bit widths for faster loading, with the FPGA driving addresses and reading synchronously or asynchronously. In processor-driven modes like slave SelectMAP (110), common in SoC FPGAs with embedded cores, an external processor supplies via an 8-, 16-, or 32-bit bus, allowing software-controlled configuration and integration with system processes.

Design Entry and Synthesis Methods

Design entry for field-programmable gate arrays (FPGAs) primarily involves hardware description languages (HDLs) such as , , and , which allow designers to specify behavior at the (RTL) or behavioral level. These languages enable the description of digital circuits through structural, dataflow, or behavioral constructs, facilitating and synthesis into FPGA fabric. High-level synthesis (HLS) provides an alternative entry method by converting higher-level languages like C, C++, or Python into RTL code suitable for FPGAs. Tools such as Vitis HLS from AMD automate this process, transforming algorithmic descriptions—such as loops—into pipelined hardware accelerators to improve throughput. For instance, pragmas like #pragma HLS PIPELINE can schedule loop iterations to achieve an initiation interval of 1 cycle, enabling concurrent execution on FPGA resources. The synthesis process begins with , which applies transformations such as constant propagation to eliminate redundant logic by substituting constant values through the design, and retiming to reposition registers for better timing balance. Following optimization, technology mapping decomposes the logic into lookup tables (LUTs) and flip-flops, inferring sequential elements from HDL constructs like always blocks in . This step targets the FPGA's programmable logic blocks, ensuring the netlist aligns with device architecture. Optimization techniques during synthesis balance area and speed trade-offs, often through pipelining, which inserts registers to divide critical paths and potentially double the achievable clock frequency at the cost of increased resource usage. , including equivalence checking, confirms that the synthesized behaves identically to the RTL source, detecting discrepancies from optimization or mapping errors. These methods ensure functional correctness without exhaustive . Soft cores, such as the RISC processor from , are configurable intellectual property (IP) blocks implemented entirely in FPGA fabric using synthesis tools. Resource utilization for these cores varies by configuration; for example, a basic microcontroller variant on a Kintex UltraScale+ device consumes approximately 2,228 LUTs and achieves 399 MHz, while an application-optimized version uses 8,020 LUTs at 281 MHz. Utilization is typically calculated as the percentage of resources employed, given by the formula: % used=(LUTs placedtotal LUTs)×100\% \text{ used} = \left( \frac{\text{LUTs placed}}{\text{total LUTs}} \right) \times 100 This metric helps assess fit within the target FPGA.

Manufacturers and Industry Landscape

Leading Manufacturers

Advanced Micro Devices (AMD) emerged as the dominant force in the FPGA market following its $49 billion acquisition of Xilinx in October 2022, integrating Xilinx's extensive portfolio into its adaptive computing offerings. AMD's high-end FPGA lines, such as the Virtex UltraScale+ and Versal series, target demanding applications requiring superior performance and scalability, while the Spartan family addresses cost-sensitive, low-power needs with features like high I/O density and advanced security. As of 2025, AMD commands approximately 50% of the global FPGA market share, bolstered by its multi-node portfolio spanning 7nm to 16nm processes. Intel solidified its FPGA presence through the 2015 acquisition of Altera for $16.7 billion, which expanded its capabilities in programmable logic. In September 2025, Intel sold a 51% stake in Altera to Silver Lake for approximately $4.46 billion (valuing the business at $8.75 billion), retaining a 49% minority interest while granting Altera operational independence to accelerate innovation in AI and high-performance computing. Altera's Stratix and Arria families deliver high-performance solutions optimized for bandwidth-intensive tasks, whereas the Cyclone series focuses on embedded and cost-effective designs suitable for edge computing. Altera emphasizes integrated FPGA-CPU architectures, notably pairing its devices with Xeon processors via coherent interfaces to accelerate data center workloads, as seen in products like the Xeon Scalable 6138P with embedded Arria 10 GX FPGA. Holding around 30% market share in 2025, Altera's strategy leverages its ecosystem for hybrid computing, with potential for growth following the Silver Lake investment. Among other notable players, specializes in low-power FPGAs, with its iCE40 series enabling ultra-low-power applications and the platform offering enhanced performance efficiency on 28nm FD-SOI technology for small-form-factor designs. Microchip Technology's PolarFire FPGAs stand out for radiation-tolerant variants, such as the RTPF500ZT, which provide no-configuration-upset reliability for and environments without the power overhead of SRAM-based alternatives. Achronix focuses on ultra-high-speed FPGAs, exemplified by the Speedster7t family, which supports up to 12 Tbps fabric bandwidth and 400 Gbps Ethernet for high-bandwidth networking. Historical shifts in the FPGA landscape include the rise of specialized providers like QuickLogic, which develops eFPGA IP and sensor processing hubs for always-on edge AI, and Efinix, targeting applications with cost-effective, high-density alternatives. Asian manufacturers, such as Gowin Semiconductor founded in 2014, have gained traction as affordable entrants, offering FPGA solutions like the series for consumer and industrial uses, reflecting growing regional competition post-2022 mergers. The global field-programmable gate array (FPGA) market reached approximately USD 9.9 billion in 2020 and is projected to attain USD 11.73 billion in 2025, reflecting a (CAGR) of around 10% during this period. By 2030, the market is expected to expand to USD 19.34 billion, driven by a CAGR of 10.5% from 2025 onward. Key segments include data centers, which account for about 30% of the market share due to demand for ; automotive applications, comprising roughly 20% amid the rise of advanced driver-assistance systems (ADAS) and electric vehicles; and , holding approximately 35% as networks evolve. Primary growth drivers encompass AI and (ML) acceleration, where FPGAs offer customizable parallel processing for tasks; the deployment of and emerging infrastructure, requiring flexible ; and , enabling low-latency data handling in distributed systems. Economically, FPGAs exert significant impact by lowering ASIC prototyping expenses, as their reprogrammability avoids costly mask sets and iterations that can exceed tens of millions per design cycle, collectively saving the billions in development outlays across high-volume sectors like consumer devices and . Challenges include persistent supply chain disruptions from the 2021-2023 semiconductor shortages, which delayed FPGA availability and inflated prices, alongside intensifying competition from GPUs in AI workloads due to the latter's mature software ecosystems like . Looking ahead, the market is forecasted to surpass USD 20 billion by 2030, bolstered by innovations in quantum-resistant designs to counter emerging cryptographic threats from . Additionally, advancements in low-power FPGAs support sustainability efforts in , reducing energy consumption in data centers and edge devices to align with global environmental goals.

Applications

Prototyping and Development Uses

Field-programmable gate arrays (FPGAs) play a crucial role in ASIC and SoC prototyping by enabling the emulation of complete chip designs prior to fabrication. Modern FPGAs, such as those based on Virtex UltraScale architectures, can emulate designs equivalent to up to 25 million ASIC gates on a single device, allowing engineers to verify complex hardware functionality at near real-time speeds. This capability supports hardware-software co-verification, where is tested alongside the hardware using debug probes and interfaces like or high-speed serial links to monitor signals and inject stimuli in real time. Such approaches reduce risks associated with design errors that could otherwise require costly respins. FPGA-in-the-loop simulation further enhances prototyping by integrating hardware descriptions with software-based tools for algorithm validation. In this method, an HDL implementation is deployed to an FPGA board and interfaced with or models, allowing test scenarios and data to be applied directly from the software environment to the hardware for synchronized execution. This setup facilitates rapid verification of in a hardware , with reconfiguration times typically under a week, in contrast to several months for ASIC fabrication and testing cycles. In education and research, FPGAs enable hands-on learning and experimentation through affordable development boards. The Digilent Basys 3, priced at around $165 and featuring an Artix-7 FPGA, serves as an introductory platform for teaching digital design concepts, complete with switches, LEDs, and expansion options for student projects. Open-source efforts, such as implementations of processor cores on these boards, allow researchers and students to prototype custom architectures and explore instruction set extensions without constraints. The primary benefits of FPGA prototyping include 10-100 times faster iteration cycles compared to traditional or ASIC development, enabling pre-silicon validation that catches issues early and minimizes respins. For instance, in automotive ECU development, FPGAs support hardware-software in a pre-silicon environment, accelerating compliance with standards like and reducing overall development time by allowing extensive software validation before physical prototypes are available.

Embedded Systems and Signal Processing

Field-programmable gate arrays (FPGAs) are widely utilized in embedded systems to implement custom peripherals that enhance flexibility and performance in resource-constrained environments such as (IoT) devices and automotive applications. In automotive systems, FPGAs enable precise through (PWM) generation directly in the programmable fabric, allowing for real-time adjustments to speeds via adaptive algorithms integrated as IP cores. This approach supports high-bandwidth emulation for interior permanent magnet motors, facilitating efficient control with wide-bandgap devices. Similarly, in IoT edge nodes, FPGAs serve as customizable interfaces for and protocol bridging, reducing latency in compared to microcontroller-based solutions. Video processing pipelines in embedded systems benefit significantly from FPGAs' parallel architecture, enabling real-time operations like and conversion on platforms such as the Zybo Z7 board. These pipelines process high-resolution streams at frame rates exceeding 30 FPS, making FPGAs suitable for applications in surveillance and automotive cameras where low-power is essential. FPGAs also play a key role in advanced driver assistance systems (ADAS) for tasks, such as from and inputs, achieving deterministic timing critical for safety-critical operations. In (DSP), FPGAs excel at implementing (FIR) and (IIR) filters, as well as (FFT) engines, leveraging dedicated DSP slices for high-throughput computations. These slices support sampling rates up to 1 GSPS, enabling efficient parallel processing that delivers microsecond-level latencies—orders of magnitude faster than millisecond delays typical on CPUs—for tasks like audio and image filtering. The parallelism inherent in FPGA architectures provides a 27-fold over CPUs in FIR filter implementations, with even greater advantages in low-latency scenarios over GPUs. Telecommunications applications, particularly in New Radio (NR), employ FPGAs for processing, including adaptive equalization to mitigate channel impairments in millimeter-wave links. FPGA-based equalizers handle discrete multi-tone modulation with timing recovery, converging rapidly to optimize at gigasample rates. In and domains, radiation-hardened FPGAs like Microchip's RTG4 series are deployed for and satellite communications, featuring SEU-hardened registers and high-speed transceivers tolerant to harsh radiation environments. These devices support up to 151,824 registers and 24 lanes of 3.125 Gbps , ensuring reliable operation in space missions for compression and .

High-Performance Computing and AI

Field-programmable gate arrays (FPGAs) have become integral to high-performance computing (HPC) by enabling custom accelerators tailored for supercomputing environments, where they support specialized floating-point operations through both soft and hard intellectual property (IP) cores. In supercomputers, FPGAs facilitate efficient handling of complex numerical computations, such as those required in scientific simulations and data processing pipelines. For instance, Microsoft Azure deploys Intel Arria 10 FPGAs as accelerators for Bing search ranking, optimizing query processing and improving throughput in large-scale data analysis tasks. Soft IP cores, implemented via configurable logic blocks, allow flexible precision floating-point arithmetic, while hard IP, like dedicated DSP slices in modern FPGAs, provides high-speed multipliers and adders for sustained performance in HPC workloads. In and (AI/ML), FPGAs excel as inference engines for convolutional neural networks (s), leveraging techniques like and quantization to deploy efficient 8-bit models that reduce and latency without significant accuracy loss. The AMD Alveo U280 accelerator card, for example, delivers up to 24.5 tera operations per second (TOPS) for INT8 CNN inference, enabling real-time processing in data centers for applications like image recognition and . Compared to graphics processing units (GPUs), FPGAs offer advantages in sparse and low-batch workloads, where their reconfigurable architecture minimizes overhead for irregular data patterns and small inference batches, achieving lower latency in scenarios like personalized recommendations. FPGAs also enhance data center operations through specialized tasks such as packet processing for high-speed networking and database acceleration, where they handle massive data flows with superior efficiency. In networking, FPGAs support 400G Ethernet implementations using PAM4 modulation for low-latency packet parsing and forwarding, critical for cloud-scale infrastructures. For databases, FPGAs accelerate query execution in systems like , performing operations such as joins and aggregations directly in hardware to boost by orders of magnitude over CPU-only setups. Regarding power efficiency, FPGAs can provide 2-5 times better energy utilization than GPUs for fixed-function accelerations in s, due to their ability to optimize hardware for specific algorithms without the parallelism overhead of GPUs. Emerging trends in FPGA deployment for HPC and AI include broader support for open standards like for parallel programming and Intel's toolkit for optimized inference on FPGAs, facilitating easier integration into hybrid AI pipelines. These tools enable developers to port C++-based models to FPGA hardware with minimal reconfiguration. Recent advancements as of 2025 point toward hybrid edge-cloud architectures, where FPGAs bridge distributed AI training and inference across heterogeneous environments, enhancing scalability for large language models through custom pipelined hardware and memory optimizations that support low-latency inference, as well as growing applications in telecommunications and edge AI for autonomous systems.

Security and Reliability

Security Vulnerabilities and Attacks

Field-programmable gate arrays (FPGAs) face significant security threats due to their reconfigurable nature, which exposes the configuration and underlying hardware to various attack vectors aimed at (IP) theft, malfunction induction, or unauthorized control. These vulnerabilities arise primarily from the reliance on external configuration memory and the integration of third-party components, making FPGAs susceptible to both passive extraction of sensitive designs and active insertion of malicious logic. Attackers exploit these weaknesses to compromise systems in critical applications, such as embedded devices and environments. Bitstream reverse engineering represents a primary threat, enabling adversaries to extract proprietary designs from configured FPGAs. Side-channel attacks, such as differential power analysis, have successfully decrypted bitstreams in Virtex-II Pro devices by monitoring power consumption during the decryption process, revealing (LUT) configurations and key material. Similarly, advanced side-channel techniques have fully broken the bitstream encryption in 7-series FPGAs, allowing complete recovery of the configuration data through non-invasive power or electromagnetic analysis. Recent as of 2025 has also identified static side-channel attacks exploiting undervolting or brownout conditions in powered-down FPGAs to extract sensitive without active clock operation. IP theft via readout further exacerbates this risk, as unprotected interfaces permit direct extraction of bitstreams from the device's configuration memory, bypassing encryption in unhardened setups. Hardware Trojans introduce malicious functionality into FPGA designs, often during synthesis or integration of third-party IP, posing risks. These Trojans can manifest as backdoors that activate on specific triggers, such as rare input patterns, to leak data or alter behavior without detection during normal operation. In scenarios involving third-party IP cores, untrusted vendors may embed Trojans that create covert channels for exfiltration or modify , as demonstrated in analyses of FPGA-based systems where Trojans evade standard verification. compromises amplify this threat, with Trojans potentially inserted at design houses or fabrication stages, leading to widespread deployment in trusted hardware ecosystems. Physical attacks target the FPGA hardware directly, compromising non-volatile or volatile storage elements. In antifuse-based FPGAs, such as older devices, the technology provides resistance to invasive attacks like the chip package and probing the antifuse array, as the programmed configuration is difficult to reveal due to the physical structure and scale of the fuses. For SRAM-based FPGAs in networked settings, remote exploits analogous to have been shown feasible; for instance, FPGAhammer induces voltage faults in shared cloud FPGAs by repetitive activation patterns, causing bit flips in block RAM (BRAM) and enabling denial-of-service or from untrusted tenants. Vulnerabilities in reconfiguration processes expose FPGAs to and tampering, particularly in dynamic or remote scenarios. Man-in-the-middle attacks during over-the-air updates can and alter bitstreams transmitted to volatile FPGAs, as volatile configurations lack inherent persistence against such exploits. In FPGA-as-a-Service platforms, remote reconfiguration allows malicious users to exploit partial reconfiguration flaws, such as address manipulation faults, to inject erroneous logic or escalate privileges across isolated regions. These risks are heightened in multi-tenant environments, where unverified updates propagate exploits without physical access.

Protection Techniques and Best Practices

Field-programmable gate arrays (FPGAs) employ encryption to protect configuration data from unauthorized access and tampering, typically using AES-256 algorithms with device-unique keys stored in secure memory such as battery-backed RAM (BBRAM) in (now ) devices. This approach ensures that the can only be decrypted using the FPGA-specific key, preventing cloning or . Authentication is integrated via or AES-GCM modes, verifying bitstream integrity during loading; for instance, UltraScale+ FPGAs use -SHA for this purpose, halting configuration if tampering is detected. The U.S. Department of Defense's 2025 FPGA Security Guidance recommends using AES-256 in GCM or CTR mode with NIST CAVP validation, alongside CNSA-compliant asymmetric authentication (e.g., RSA or ECDSA) performed before decryption, and validated Hardware Security Modules (HSMs) for key generation and management. Secure boot processes in FPGAs leverage volatile Physically Unclonable Functions (PUFs) to generate unique keys on-device, enhancing partitioning in multi-tenant environments by deriving ephemeral keys that cannot be cloned due to manufacturing variations. In Zynq UltraScale+ devices, PUFs produce "black keys" stored in encrypted form for authentication, supporting secure partitioning of FPGA resources. For cloud-based multi-tenant FPGAs, remote attestation protocols verify the integrity of loaded bitstreams and runtime configurations, allowing tenants to confirm isolation without trusting the host infrastructure. Best practices for FPGA security include obfuscation techniques, such as inserting dummy logic or remapping resources to hinder , which can be combined with for layered protection at low overhead. of (IP) cores ensures absence of backdoors or vulnerabilities through mathematical proofs of security properties, as applied in mission-critical FPGA designs. Disabling interfaces post-configuration mitigates debugging-based attacks; 28-nm FPGAs support secure mode, activated via or instructions to block non-essential access. In system-on-chip (SoC) FPGAs, hardware roots of trust like 's Secure Device Manager provide immutable for and attestation. The DoD guidance further advises implementing tamper detection sensors with automatic responses (e.g., key zeroization), preferring flash-based FPGAs for internal storage, and following NIST SP 800-57 for key rotation and end-of-life destruction procedures. To address reliability against soft errors, which can compromise security in radiation-prone environments, error-correcting codes (ECC) are implemented on block RAM (BRAM), enabling single-error correction and double-error detection in Xilinx FPGAs. For single-event upsets (SEUs) in space applications, triple modular redundancy (TMR) replicates critical logic modules and uses majority voting to mask faults, though it incurs approximately 3x area overhead. These techniques ensure continued secure operation by maintaining configuration integrity against environmental threats.

Programmable Logic Devices

Programmable logic devices (PLDs) encompass a of integrated circuits that allow users to implement custom digital logic functions through reconfiguration, serving as precursors and complements to field-programmable arrays (FPGAs). These devices evolved from early discrete logic replacements to more sophisticated structures, categorized primarily into simple PLDs (SPLDs) and complex PLDs (CPLDs), each suited to specific scales and applications. Unlike FPGAs, which emphasize for large designs, PLDs prioritize and predictability in smaller contexts. Simple programmable logic devices (SPLDs), such as (PAL) and (GAL) devices, are the most basic form of reprogrammable logic, designed for straightforward combinational and sequential functions like glue logic in digital systems. SPLDs typically feature a programmable AND array feeding a fixed OR array, enabling the implementation of sum-of-products expressions with limited flip-flops for state storage, and they operate in technologies like for reliable, one-time or limited reprogramming. With low pin counts generally under 100—often 16 to 28 pins—and capacities equivalent to hundreds of gates, SPLDs excel in cost-sensitive, low-complexity tasks such as decoding or interface buffering, but lack the density for broader integration. Examples include the classic 22V10 GAL, which provides 10 macrocells and supports up to 12 inputs per cell. Complex programmable logic devices (CPLDs) extend SPLD concepts to higher densities, incorporating multiple macrocells organized around shared arrays within logic array blocks, interconnected via a fixed global routing structure. This architecture, often based on sea-of-gates or product-term , supports a few thousand to tens of thousands of gates—typically 256 to 512 macrocells—making CPLDs suitable for small-scale state machines, protocol bridges, and control logic where fast configuration and predictable timing are critical. Configuration occurs in nanoseconds upon power-up due to non-volatile Flash or storage, offering lower power and simpler flows than FPGAs, though with reduced routing flexibility from the centralized interconnect. Notable examples include the CoolRunner-II family, which uses a 1.8V Flash-based for ultra-low power consumption (under 100 µA static) and high-speed operation up to 400 MHz. Key differences between these PLDs and FPGAs lie in scale, , and use cases: SPLDs and CPLDs handle designs up to a few thousand gates with fixed or semi-fixed interconnects for deterministic performance, ideal for small, fast state machines, while FPGAs accommodate 100,000+ gates via a programmable of lookup tables (LUTs) and switch matrices, enabling complex, flexible routing at the expense of longer configuration times (milliseconds) and variable timing analysis. CPLDs, for instance, avoid the routing congestion of FPGAs' distributed , providing pin-locking and easier verification for , but they cannot scale to data-intensive applications without multiple devices. The evolution of PLDs traces back to the 1970s with the introduction of programmable read-only memories (PROMs) and the first PAL devices in 1978 by Monolithic Memories Inc., which replaced discrete TTL logic for basic functions. The 1980s saw CPLDs emerge as multi-array extensions, with FPGAs following in 1985 via Xilinx's XC2064, shifting toward array-based programmability. By the 2020s, hybrid devices blending FPGA flexibility with CPLD-like instant-on and low-density features have appeared, such as Lattice Semiconductor's Certus-NX , which integrates up to 39,000 logic cells in small packages with non-volatile options for and secure control. In 2025, Lattice introduced the MachXO5-NX TDQ , offering support in low-power programmable logic for enhanced security in embedded systems. This progression reflects ongoing demands for power efficiency and integration in embedded systems.

Alternative Hardware Acceleration Options

Graphics processing units (GPUs) offer massive parallelism suited for graphics rendering and workloads, with devices like the A100 featuring 6912 cores and 432 tensor cores for accelerated matrix operations. However, GPUs typically consume more power, such as the A100's 400 W (TDP), compared to high-end FPGAs that often operate at around 100 W while providing greater customizability through reconfigurable logic for specialized tasks. This flexibility allows FPGAs to interface directly with diverse hardware via customizable I/O, whereas GPUs rely on fixed architectures optimized for general-purpose . Tensor processing units (TPUs) and application-specific integrated processors (ASIPs), such as Google's TPUs, are designed for tensor operations in , delivering high efficiency for fixed workloads like convolutional neural networks. While TPUs provide up to 10 times the energy efficiency of GPUs for specific models due to their tailored architecture, they lack the reconfigurability of FPGAs, limiting adaptability to non-standard tasks. FPGAs, in contrast, enable custom pipelines that can achieve superior latency and power savings for diverse scenarios beyond rigid TPU optimizations. Neuromorphic chips, exemplified by Intel's Loihi, emulate brain-like with asynchronous processing for event-driven computations, supporting up to 130,000 neurons on a single chip. Quantum annealers like D-Wave's Advantage system accelerate problems through quantum tunneling effects, handling over 5,000 qubits for tasks intractable on classical hardware. FPGAs are preferred for low-latency, protocol-specific acceleration, such as cryptographic operations, where implementations like point multiplication on FPGAs achieve low-microsecond latencies unattainable by more general accelerators. Hybrid systems integrating CPUs, FPGAs, and GPUs in data centers, as seen in Microsoft's Azure configurations, leverage each component's strengths—CPUs for , GPUs for parallel training, and FPGAs for real-time acceleration—to optimize overall workload efficiency. Emerging post-2020 alternatives include hardware, such as photonic processors from Lightmatter, which perform matrix multiplications at light speed with significantly lower energy use than electronic counterparts, targeting AI inference in large-scale environments.

References

  1. https://www.ni.com/en/shop/electronic-test-instrumentation/add-ons-for-electronic-test-and-instrumentation/what-is-labview-fpga-module/fpga-fundamentals.html
  2. https://www.intel.com/content/www/us/en/docs/programmable/683521/21-3/fpga-overview.html
  3. https://www.cs.umd.edu/~meesh/cmsc411/website/proj01/fpgas/
  4. http://r5.ieee.org/ctx-cn/wp-content/uploads/sites/46/fpga_timeline_n_applications_180525.pdf
  5. https://www.eejournal.com/article/with-18-5-million-logic-cells-amds-versal-vp1902-premium-adaptive-soc-becomes-worlds-largest-fpga/
  6. https://www.computerhistory.org/siliconengine/pal-user-programmable-logic-devices-introduced/
  7. https://www.eejournal.com/article/how-the-fpga-came-to-be-part-3/
  8. https://queue.acm.org/detail.cfm?id=3411759
  9. https://www.eejournal.com/article/how-the-fpga-came-to-be-part-5/
  10. http://pldworld.org/_xilinx/html/heritage/Fabless%2520Book%2520Chapter%2520FINAL.pdf
  11. https://patents.google.com/patent/US4870302A/en
  12. http://bitsavers.org/components/xilinx/fpga/XC2000/Xilinx_XC2064_Press_Release_OCR.pdf
  13. https://semiwiki.com/fpga/1596-a-brief-history-of-fpgas/
  14. https://cacm.acm.org/practice/the-history-status-and-future-of-fpgas/
  15. https://www.xilinx.com/publications/archives/books/dsp.pdf
  16. https://people.ece.uw.edu/hauck/publications/mFPGAhard.pdf
  17. https://www.eecg.toronto.edu/~pc/research/publications/lego1.tvlsi99.pdf
  18. http://users.ece.cmu.edu/~jhoe/course/ece643/latest/L03.pdf
  19. https://www.amd.com/en/newsroom/press-releases/2024-4-17-amd-announces-versal-ai-edge-gen-2-series-adaptive-socs.html
  20. https://www.marketsandmarkets.com/PressReleases/fpga.asp
  21. https://www.amd.com/en/newsroom/press-releases/2022-2-14-amd-completes-acquisition-of-xilinx.html
  22. https://www.eetimes.com/fpga-market-to-reach-9-9b-by-2020/
  23. https://yosyshq.net/yosys/
  24. https://www.arm.com/glossary/fpga
  25. https://www.intel.com/content/www/us/en/docs/programmable/683269/current/using-the-design-security-features-in-fpgas.html
  26. https://www.allaboutcircuits.com/technical-articles/purpose-and-internal-functionality-of-fpga-look-up-tables/
  27. https://nandland.com/lesson-4-what-is-a-look-up-table-lut/
  28. https://learn.sparkfun.com/tutorials/how-does-an-fpga-work/look-up-tables
  29. https://hardwarebee.com/overview-of-lookup-tables-in-fpga-design/
  30. https://www.intel.com/content/www/us/en/docs/programmable/683389/22-4/partial-reconfiguration.html
  31. https://www.doulos.com/media/1171/xilinx_partial_reconfiguration.pdf
  32. https://docs.amd.com/r/en-US/ug908-vivado-programming-debugging/Generating-the-Bitstream-or-Device-Image
  33. https://cdrdv2-public.intel.com/653665/an311.pdf
  34. https://www.intel.com/content/www/us/en/fpga-solutions/healthcare/overview.html
  35. https://ieeexplore.ieee.org/iel7/5/7086369/07086413.pdf
  36. https://www.researchgate.net/publication/3226002_Measuring_the_gap_between_FPGAs_and_ASICs
  37. https://arxiv.org/pdf/2510.26985
  38. https://cdrdv2-public.intel.com/650491/wp-01255-top-10-reasons-to-replace-your-microcontroller-with-a-max-10-fpga.pdf
  39. https://www.xilinx.com/publications/archives/magazines/dsp02.pdf
  40. https://ieeexplore.ieee.org/iel7/6287639/6514899/09610039.pdf
  41. https://www.xilinx.com/virtex-ultrascale-plus
  42. https://ieeexplore.ieee.org/iel7/6287639/6514899/10158531.pdf
  43. https://www.xilinx.com/support/documents/sw_manuals/ug1228-ultrafast-embedded-design-methodology-guide.pdf
  44. https://docs.amd.com/r/en-US/ug474_7Series_CLB
  45. https://www.intel.com/content/www/us/en/docs/programmable/683729/current/adaptive-logic-module-alm.html
  46. https://www.amd.com/en/products/adaptive-socs-and-fpgas/versal/premium-series.html
  47. https://cdrdv2-public.intel.com/652414/stratix-10-dx-product-table.pdf
  48. https://cse.usf.edu/~haozheng/teach/cda4253/doc/fpga-arch-overview.pdf
  49. http://www.gstitt.ece.ufl.edu/courses/eel4720_5721/reading/Routing.pdf
  50. https://people.ece.ubc.ca/stevew/papers/pdf/imran_masc.pdf
  51. https://www.eecg.toronto.edu/~jayar/pubs/betz/fpga99betz.pdf
  52. https://www.eecg.toronto.edu/~vaughn/papers/fpga98.pdf
  53. https://www.ttcenter.ir/ArticleFiles/ENARTICLE/3772.pdf
  54. https://www.eecg.utoronto.ca/~brown/papers/cicc.seg.pdf
  55. https://www.eecg.toronto.edu/~brown/papers/ccvlsi93-khellah.pdf
  56. https://docs.amd.com/api/khub/documents/JyLws_jflXaM1Jjy2RgQAQ/content
  57. https://cdrdv2-public.intel.com/816251/ug-20330-683544-816251.pdf
  58. https://docs.amd.com/r/en-US/ug861-ultrascale-selectio/PULLTYPE-Attribute
  59. https://cdrdv2-public.intel.com/655005/cyiv-51006.pdf
  60. https://cdrdv2-public.intel.com/762192/ug-762191-762192.pdf
  61. https://www.intel.com/programmable/technical-pdfs/683195.pdf
  62. https://users.ece.utexas.edu/~mcdermot/arch/articles/Zynq/ug472_7Series_Clocking.pdf
  63. https://cdrdv2-public.intel.com/769133/ug-ag-clkpll-683761-769133.pdf
  64. https://docs.amd.com/r/en-US/ug572-ultrascale-clocking/Dynamic-Phase-Shift-Interface-in-the-MMCM
  65. https://www.allaboutcircuits.com/technical-articles/clock-management-clock-resources-of-fpgas/
  66. https://cdrdv2-public.intel.com/654310/an327.pdf
  67. https://www.amd.com/en/products/adaptive-socs-and-fpgas/technologies/high-speed-serial.html
  68. https://www.eejournal.com/article/20040810_mentor/
  69. https://docs.amd.com/r/en-US/am007-versal-memory/Block-RAM-Summary
  70. https://docs.amd.com/r/en-US/ug585-zynq-7000-SoC-TRM/Block-RAM
  71. https://www.intel.com/content/www/us/en/docs/programmable/683082/22-2/true-dual-port-synchronous-ram.html
  72. https://www.xilinx.com/publications/archives/xcell/Xcell59.pdf
  73. https://www.xilinx.com/publications/archives/xcell/Xcell78.pdf
  74. https://www.intel.com/content/www/us/en/docs/programmable/683578/23-1/about-e-tile-hard-ip-design-examples.html
  75. https://www.amd.com/en/products/adaptive-socs-and-fpgas/soc/zynq-ultrascale-plus-mpsoc.html
  76. https://www.arm.com/glossary/heterogeneous-compute
  77. https://arxiv.org/abs/2503.09318
  78. https://www.sciencedirect.com/science/article/abs/pii/S0957417421002219
  79. https://docs.amd.com/api/khub/documents/jcXzYXzAZP1LXWncl0_Oig/content
  80. https://dl.acm.org/doi/10.1145/1508128.1508203
  81. https://www.computerworld.com/article/1658929/intel-ships-stratix-10-dx-fpgas-with-pcie-4-and-optane-support-partners-with-vmware.html
  82. https://www.amd.com/en/products/adaptive-socs-and-fpgas/versal/ai-edge-series.html
  83. https://www.amd.com/en/products/adaptive-socs-and-fpgas/versal/premium-series/vp1902.html
  84. https://www.amd.com/en/products/adaptive-socs-and-fpgas/versal/gen2/premium-series.html
  85. https://dl.acm.org/doi/abs/10.1145/3529650
  86. https://insidehpc.com/2025/07/charting-the-photonic-future-of-ai-interconnect/
  87. https://www.mdpi.com/2624-960X/6/4/39
  88. https://ww1.microchip.com/downloads/aemdocuments/documents/fpga/ProductDocuments/SupportingCollateral/lapu_wp.pdf
  89. https://www.psmarketresearch.com/market-analysis/field-programmable-gate-array-fpga-market
  90. https://cdrdv2-public.intel.com/666920/cfg_cf51001-683692-666920.pdf
  91. https://ww1.microchip.com/downloads/aemdocuments/documents/fpga/ProductDocuments/SupportingCollateral/flashspaceapps.pdf
  92. https://ww1.microchip.com/downloads/aemdocuments/documents/fpga/ProductDocuments/SupportingCollateral/antifusesecuritywp.pdf
  93. https://www.edaboard.com/threads/small-size-fpgas-actel-or-lattice.257869/
  94. https://ww1.microchip.com/downloads/aemDocuments/documents/FPGA/ProductDocuments/DataSheets/rtpa3_ds.pdf
  95. https://www.edn.com/2-mb-fram-is-ready-to-serve-space-grade-fpgas-processors/
  96. https://www.researchgate.net/publication/221914703_Use_of_FRAM_Memories_in_Spacecrafts
  97. https://www.latticesemi.com/en/Blog/2025/01/16/16/41/From-Flash-to-MRAM
  98. https://www.everspin.com/accelerating-space-innovation-power-fpga-and-mram-next-generation-aerospace-technologies
  99. https://docs.amd.com/r/en-US/ug901-vivado-synthesis
  100. https://www.mathworks.com/help/wireless-testbench/ug/generate-bitstream-and-program-fpga.html
  101. https://adaptivesupport.amd.com/s/article/23758
  102. https://www.intel.com/content/www/us/en/docs/programmable/683719/current/changing-the-tck-frequency.html
  103. https://www.intel.com/content/www/us/en/docs/programmable/683801/current/fpga-jtag-configuration-timing.html
  104. https://cdrdv2-public.intel.com/691442/wp-01137-stxv-dynamic-partial-reconfig.pdf
  105. https://vipinkizheppatt.github.io/publications/pr_survey.pdf
  106. https://docs.amd.com/r/2021.2-English/ug900-vivado-logic-simulation/Running-Post-Synthesis-and-Post-Implementation-Simulations
  107. https://www.altera.com/products/development-tools/quartus
  108. https://www.intel.com/content/www/us/en/docs/programmable/683248/18-0/simulation-quick-start.html
  109. https://github.com/YosysHQ/nextpnr
  110. https://arxiv.org/pdf/1903.10407
  111. https://www.eecg.utoronto.ca/~kmurray/vtr/symbiflow_vpr_micro.pdf
  112. https://hackaday.com/2019/11/01/symbiflow-open-source-fpga-toolchain/
  113. https://www.amd.com/en/products/software/adaptive-socs-and-fpgas/vivado/implementation.html
  114. https://www.intel.com/content/www/us/en/support/programmable/support-resources/design-guidance/quartus-support.html
  115. https://cdrdv2-public.intel.com/653908/tt_my_first_fpga.pdf
  116. https://docs.amd.com/r/en-US/ug1399-vitis-hls
  117. https://docs.amd.com/r/en-US/ug904-vivado-implementation/Constant-Propagation-Default
  118. http://www-cad.eecs.berkeley.edu/~alanmi/publications/2005/iwls05_smr.pdf
  119. https://www.intel.com/content/www/us/en/docs/programmable/683082/22-2/hdl-design-guidelines.html
  120. https://ieeexplore.ieee.org/document/317471/
  121. https://www.csl.cornell.edu/~zhiruz/pdfs/pipemap-dac2015.pdf
  122. https://adaptivesupport.amd.com/s/article/25007
  123. https://resources.sw.siemens.com/en-US/video-equivalence-checking-for-fpga/
  124. https://www.amd.com/en/products/adaptive-socs-and-fpgas/intellectual-property/microblazecore.html
  125. https://docs.amd.com/r/en-US/ug1629-microblaze-v-user-guide/Resource-Utilization
  126. https://thevoltpost.com/top-fpga-technology-companies-in-2025-trends/
  127. https://www.amd.com/en/products/adaptive-socs-and-fpgas/fpga.html
  128. https://www.stockopine.com/p/amd-deep-dive-from-underdog-to-ai
  129. https://www.marketsandmarkets.com/Market-Reports/fpga-market-194123367.html
  130. https://www.altera.com/newsroom/news/press-release/altera-silver-lake
  131. https://www.reuters.com/markets/deals/intel-sell-51-stake-altera-silver-lake-2025-04-14/
  132. https://www.mouser.com/pdfDocs/intel-fpga-product-catalog.pdf
  133. https://www.datacenterdynamics.com/en/news/intel-launches-xeon-with-integrated-fpga/
  134. https://www.magmio.com/news/139-fpga-companies
  135. https://www.latticesemi.com/LatticeNexus
  136. https://www.microchip.com/en-us/products/fpgas-and-plds/radiation-tolerant-fpgas/rt-polarfire-fpgas
  137. https://www.achronix.com/product/speedster7t-fpgas
  138. https://www.quicklogic.com/
  139. https://gowinsemi.com/
  140. https://www.mordorintelligence.com/industry-reports/field-programmable-gate-array-fpga-market
  141. https://market.us/report/fpga-market/
  142. https://www.transparencymarketresearch.com/field-programmable-gate-array.html
  143. https://www.einfochips.com/blog/asic-prototyping-and-asic-vs-fpga-which-one-to-consider/
  144. https://www.linkedin.com/posts/samagata-semiconductors-community_tutorialseries-vlsi-fpga-activity-7385325729577824256-Bx_M
  145. https://www.atlanticcouncil.org/in-depth-research-reports/report/to-secure-reprogrammable-chips-the-us-must-address-supply-chain-risks/
  146. https://www.marketsandmarkets.com/ResearchInsight/ai-impact-analysis-fpga-industry.asp
  147. https://www.latticesemi.com/en/Blog/2024/11/18/16/50/Blog-How-FPGAs-Enable-Flexible-Secure-Green-Telecommunications
  148. https://arxiv.org/html/2311.12396v2
  149. https://www.cadence.com/content/dam/cadence-www/global/en_US/documents/tools/system-design-verification/protium-s1-fpga-based-prototyping-platform-ds.pdf
  150. https://img.electronicdesign.com/files/base/ebm/electronicdesign/document/2019/03/electronicdesign_10872_rizzatti_0.pdf?dl=electronicdesign_10872_rizzatti_0.pdf
  151. https://www.mathworks.com/help/hdlverifier/fpga-in-the-loop.html
  152. https://www.doc.ic.ac.uk/~wl/teachlocal/arch/killasic.pdf
  153. https://digilent.com/shop/basys-3-amd-artix-7-fpga-trainer-board-recommended-for-introductory-users/
  154. https://ieeexplore.ieee.org/document/9751566/
  155. https://arxiv.org/html/2509.20543
  156. https://www.ai-online.com/2011/10/fast-tracking-ecu-development-2/
  157. https://www.mdpi.com/2079-9268/15/3/40
  158. https://ww1.microchip.com/downloads/aemDocuments/documents/FPGA/ProductDocuments/DataSheets/RTG4_FPGA_Datasheet.pdf
  159. https://www.microsoft.com/en-us/research/project/project-catapult/
  160. https://arxiv.org/abs/2511.06174
  161. https://www.usenix.org/system/files/sec20-ender.pdf
  162. https://eprint.iacr.org/2021/746.pdf
  163. https://news.rub.de/english/2025-10-17-it-security-researchers-uncover-new-security-vulnerability-fpga-chips
  164. https://sailin.luddy.indiana.edu/papers/duncan2019fpga.pdf
  165. https://par.nsf.gov/servlets/purl/10318426
  166. https://www.researchgate.net/publication/266656703_Hardware_trojan_attacks_in_FPGA_devices_Threat_analysis_and_effective_counter_measures
  167. https://www.mdpi.com/2410-387X/8/3/36
  168. https://www.eetimes.com/how-to-protect-intellectual-property-in-fpgas-devices-part-1/
  169. https://d-nb.info/1205093664/34
  170. https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-763.pdf
  171. https://arxiv.org/abs/2502.15578
  172. https://docs.amd.com/r/en-US/xapp1267-encryp-efuse-program/BBRAM
  173. https://www.xilinx.com/support/documents/sw_manuals/xilinx2022_2/ug1283-bootgen-user-guide.pdf
  174. https://docs.amd.com/r/en-US/xapp1267-encryp-efuse-program/Bitstream-Authentication
  175. https://dl.acm.org/doi/10.1145/1950413.1950432
  176. https://media.defense.gov/2025/Jan/07/2003625567/-1/-1/0/CTR_FPGA_SECURITY_GUIDANCE.PDF
  177. https://xilinx.github.io/Embedded-Design-Tutorials/docs/2021.1/build/html/docs/Introduction/ZynqMPSoC-EDT/9-secure-boot.html
  178. https://www.vemeko.com/blog/67173.html
  179. https://www.ukrise.org/wp-content/uploads/2023/07/Trusted-Configuration-in-Cloud-FPGAs.pdf
  180. https://dl.acm.org/doi/10.1145/3713078
  181. https://www.ece.ufl.edu/wp-content/uploads/sites/119/publications/reconfig17.pdf
  182. https://www.osti.gov/servlets/purl/1055616
  183. https://www.intel.com/content/www/us/en/docs/programmable/683269/current/jtag-secure-mode-for-28-nm-and-20-nm-fpgas.html
  184. https://www.intel.com/content/www/us/en/docs/programmable/794424/current/hardware-root-of-trust.html
  185. https://www.rambus.com/security/root-of-trust/root-of-trust-for-fpgas/
  186. https://onlinelibrary.wiley.com/doi/abs/10.1155/2017/5419767
  187. https://ntrs.nasa.gov/api/citations/20180006778/downloads/20180006778.pdf
  188. https://www.eecg.toronto.edu/~jayar/pubs/brown/survey.pdf
  189. https://www.globalspec.com/learnmore/semiconductors/programmable_logic_devices/spld
  190. https://uk.rs-online.com/web/content/discovery/ideas-and-advice/simple-programmable-logic-devices-guide
  191. https://digilent.com/blog/pal-vs-cpld-vs-fpga/
  192. https://hardwarebee.com/introduction-to-cpld/
  193. https://www.wevolver.com/article/cpld-vs-fpga-a-comprehensive-technical-analysis-and-implementation-guide
  194. https://docs.amd.com/v/u/en-US/ds090
  195. https://www.logic-fruit.com/blog/fpga/fpga-vs-cpld/
  196. https://resources.pcb.cadence.com/blog/2019-cpld-vs-fpga-which-do-you-need-for-your-digital-system
  197. https://www.latticesemi.com/Products/FPGAandCPLD/Certus-NX
  198. https://www.latticesemi.com/en/About/Newsroom/PressReleases/2025/Lattice-Launches-Industry-First-PQC-Ready-FPGA-Family-MachXO5-NX-TDQ
  199. https://www.techpowerup.com/gpu-specs/a100-pcie-40-gb.c3623
  200. https://www.nvidia.com/content/dam/en-zz/Solutions/Data-Center/a100/pdf/nvidia-a100-datasheet-nvidia-us-2188504-web.pdf
  201. https://adaptivesupport.amd.com/s/question/0D52E00006iHsKiSAK/gpus-vs-fpgas?language=en_US
  202. https://cloud.google.com/tpu
  203. https://www.wevolver.com/article/tpu-vs-gpu-in-ai-a-comprehensive-guide-to-their-roles-and-impact-on-artificial-intelligence
  204. https://www.watelectronics.com/fpga-vs-gpu-vs-tpu/
  205. https://www.intel.com/content/www/us/en/research/neuromorphic-computing.html
  206. https://www.dwavequantum.com/solutions-and-products/systems/
  207. https://www.mdpi.com/2078-2489/10/9/285
  208. https://www.microsoft.com/en-us/research/wp-content/uploads/2016/10/Cloud-Scale-Acceleration-Architecture.pdf
  209. https://lightmatter.co/blog/a-new-kind-of-computer/
Add your contribution
Related Hubs
User Avatar
No comments yet.