TDEB Top Bar

Trending
Semiconductor Industry News — The Digital Electronics Blog
Follow Us

TDEB Masthead

The Semiconductor Hub

Semiconductors.  Chips and Systems.  Innovation.

Indexed by leading Search Engines, AI and referenced by Engineers worldwide 500+ Articles 10M+ Pageviews 30+ Reports 50+ Citations

OpenFPGA: Open Standards for FPGA Computing

Aarthi Chinappa
by
0
Share Facebook X LinkedIn WhatsApp Email

First published April 21, 2009. Kept as a dated record of the OpenFPGA consortium.

OpenFPGA (Internet Archive copy of its 2008 home page) was a consortium working to make reconfigurable computing, meaning FPGAs used as compute accelerators, easier to adopt in high-performance and enterprise computing. Its focus was the practical barriers: making FPGA applications portable between vendors and systems, making them interoperate, and defining how the software and FPGA parts of an application talk to each other.

What reconfigurable computing means

A CPU runs one instruction stream through fixed hardware. An FPGA can be configured into a custom circuit for one job, such as a filter, a search or a numerical kernel, and then reconfigured for another. For the right workload, that custom circuit can process data in a deep pipeline with many operations per clock cycle, which is why researchers and companies tried FPGAs as accelerators next to CPUs.

The obstacle in the 2000s was not raw speed but effort. Each FPGA board vendor had its own drivers, its own way to load a design and its own interface for moving data. An application written for one system did not run on another.

What OpenFPGA did

According to the archived site, as of late 2008:

  • The initiative started in 2004, with an international steering group and support from the University of Dayton.
  • It incorporated as a non-profit and named a board of directors in May 2006; AMD became its first cornerstone sponsor in November 2006.
  • Participants came from more than 200 organizations in 40 countries, through mailing lists and working groups.
  • Its General API working group released draft version 0.4 of a cross-vendor General FPGA API for public comment, reviewed at a forum during the Reconfigurable Systems Summer Institute at NCSA on July 7 to 9, 2008.
  • With SRC Computers and the University of Dayton it set up a validation and training lab at Dayton, announced in April 2008, giving members access to an SRC-7 system.
  • The site highlighted work at GE using FPGAs to speed parts of computational fluid dynamics models of jet engines.

Why a common API matters

A standard API lets an application call the same functions to find an accelerator, load a design, move data and start work, whatever board is installed. The FPGA vendor or board maker then supplies the layer underneath. It answers the main question for any accelerator: how much code must change when the hardware changes?

Deep dive: the numbers and details

This part holds the math that decides whether an FPGA accelerator pays off, and the steps a host program goes through. Skip it if the overview is all you need.

When does offloading pay?

Amdahl's law sets the ceiling. If a fraction p of run time can be accelerated by a factor s:

speedup = 1 / ((1 - p) + p / s)

Moving data to and from the FPGA adds time. Including a transfer cost t (as a fraction of the original run time):

speedup = 1 / ((1 - p) + p / s + t)

Worked example: a kernel takes 80 percent of run time (p = 0.8) and the FPGA runs it 20 times faster (s = 20). Without transfer cost, speedup = 1 / (0.2 + 0.04) = 4.2x. If moving the data costs 10 percent of the original time (t = 0.1), speedup = 1 / (0.2 + 0.04 + 0.1) = 2.9x. If the kernel is only half the run time, even an infinitely fast FPGA gives at most 2x. These numbers are illustrative.

What a host program does

Whatever the API, a host program using an FPGA accelerator goes through the same steps:

  1. Discover and open the accelerator device.
  2. Load the configuration (bitstream) for the required function.
  3. Allocate buffers and copy input data to the device.
  4. Start the function and wait for completion, or overlap it with other work.
  5. Copy results back and release the device.

Steps 2 and 3 are where vendor differences caused the most porting work, and where a common API saves the most effort. Loading a bitstream takes time, so applications usually load a design once and reuse it for many calls.

What happened next

The Internet Archive's captures of openfpga.org show the home page served normally through 2008, and from January 2009 onward the address only returned redirects, so the original site was no longer published in its old form. We did not find a source on the final status of the General FPGA API.

The name is now also used by an unrelated project: OpenFPGA on GitHub (lnis-uofu), an open-source FPGA IP generator. It is a different effort from the 2004 to 2008 consortium described here.

Share Facebook X LinkedIn WhatsApp Email

Post a Comment

0 Comments

Your comments will be moderated before it appears here.

Post a Comment (0)

#buttons=(Ok, Go it!) #days=(20)

Our website uses cookies to enhance your experience. Learn more
Ok, Go it!