In an earlier "Ask Max" column, we looked at the most fundamental type of FPGA fabric, which comprises islands of logic (programmable logic blocks) in a sea of programmable interconnect. Each programmable block contains one or more lookup tables (LUTs), along with other digital functions, like a multiplexer and register. (See: Ask Max: What's Inside a Simple FPGA?.)
Xilinx (this site's sponsor) introduced the very first FPGA, the XC2064, in 1985. It contained an eight-by-eight array of logic blocks, each boasting a four-input LUT along with other simple functions. Since they were limited in terms of capacity, early FPGAs were employed only for relatively simple tasks, like gathering glue logic or implementing rudimentary state machines. Over time, however, things changed.
More sophisticated FPGA architectures
Year by year and node by node (we will be discussing technology nodes in a future column), the capacity and performance of FPGAs increased, and power consumption decreased.
The widespread use of four-input LUTs persisted until around 2006. In fact, the smaller FPGA families still use four-input LUTs, but higher-end devices may use six-, seven-, or eight-input LUTs. These big boys may be used as a single large LUT or split into smaller functions, such as two four-input LUTs or a three-input and a five-input LUT. In a really high-end device, this programmable fabric is capable of representing the equivalent of millions (sometimes tens of millions) of primitive logic gates.
If a logical function -- say, a counter -- is implemented using the FPGA's programmable fabric, that function is said to be soft. By comparison, if a function is implemented directly in the silicon, it is said to be hard. As these functions become larger and more complex, we tend to refer to them as cores. The advantage of soft cores is that you can make them do whatever you want. The advantage of hard cores is that they occupy less silicon real estate, offer higher performance, and consume less power. The optimal solution is to have a mix of soft cores (implemented in programmable fabric) and hard cores (implemented directly in the silicon). Thus, in addition to their LUT-based programmable fabric, today's FPGAs may be augmented with a variety of hard cores as illustrated below:
A more sophisticated FPGA architecture.
For example, the device might contain thousands of adders, multipliers, and digital signal processing (DSP) functions; megabits of on-chip memory; a large number of high-speed serial interconnect (SERDES) transceiver blocks; and a host of other functions.
Perhaps now you understand why, in my very first column on All Programmable Planet, I wrote, "The FPGA moniker no longer reflects the capabilities and functionality of today's programmable devices." In that column, I also wrote that we really need to come up with some new terminology that embraces everything today's state-of-the-art tools and technologies can do. Iím sure you wonít be surprised to hear we shall be discussing this aspect of things in the not-so-distant future.
FPGAs with embedded processors
This is where things start to get really exciting. You can use a portion of the regular programmable fabric in an FPGA to implement one or more soft processor cores. And, of course, you can implement processors of different sizes. For example, you might create one or more eight-bit processors along with one or more 16- or 32-bit soft processors -- all in the same device.
If the FPGA vendor wishes to provide a higher-performance processor that occupies less silicon real estate and consumes less power, the solution is to implement it as a hard core, all of which leads us to... a future Ask Max column (grin).
Do you have any questions about this column? If so, please post them here as comments. And remember that you can search for "Ask Max" to find other columns in this series quickly.