scispace - formally typeset
Search or ask a question
Journal ArticleDOI

Examining the viability of FPGA supercomputing

01 Jan 2007-Eurasip Journal on Embedded Systems (Springer International Publishing)-Vol. 2007, Iss: 1, pp 13-13
TL;DR: A comparative analysis of FPGAs and traditional processors is presented, focusing on floating-point performance and procurement costs, revealing economic hurdles in the adoption of FFPAs for general high-performance computing (HPC).
Abstract: For certain applications, custom computational hardware created using field programmable gate arrays (FPGAs) can produce significant performance improvements over processors, leading some in academia and industry to call for the inclusion of FPGAs in supercomputing clusters This paper presents a comparative analysis of FPGAs and traditional processors, focusing on floating-point performance and procurement costs, revealing economic hurdles in the adoption of FPGAs for general high-performance computing (HPC)

Summary (2 min read)

1. INTRODUCTION

  • Supercomputers have experienced a resurgence, fueled by government research dollars and the development of lowcost supercomputing clusters constructed from commodity PC processors.
  • Floating-point arithmetic is so prevalent that the benchmarking application ranking supercomputers, LINPACK, heavily utilizes doubleprecision floating-point math.
  • Section 3 describes alternatives to floating-point implementations in FPGAs, presenting a balanced benchmark for comparing FPGAs to processors.

2.1. HPC implementations

  • The availability of high-performance clusters incorporating FPGAs has prompted efforts to explore acceleration of HPC applications.
  • While not an exhaustive list, Table 1 provides a survey of recent representative applications.
  • The SRC-6 and 6E combine two Xeon or Pentium processors with two large Virtex-II or Virtex-II Pro FPGAs.
  • The abbreviations SP and DP refer to single-precision and double-precision floating point, respectively.
  • While the speedups provided in the table are not normalized to a common processor, a trend is clearly visible.

2.2. Theoretical floating-point performance

  • FPGA designs may suffer significant performance penalties due to memory and I/O bottlenecks.
  • As most clusters incorporating FPGAs also include a host processor to handle serial tasks and communication, it is reasonable to assume that the cost analysis in Table 2 favors FPGAs.
  • For Xilinx's double-precision floatingpoint core 16 of these 18-bit multipliers are required [35] for each multiplier, while for the Dou et al. design only nine are needed.
  • While the larger FPGA devices that are prevalent in computational accelerators do not provide a cost benefit for the double-precision floating-point calculations required by the HPC community, historical trends [42] suggest that FPGA performance is improving at a rate faster than that of processors.
  • In both graphs, the latest data point, representing the largest Virtex-4 device, dis-plays worse cost-performance than the previous generation of devices.

2.3. Tools

  • The typical HPC user is a scientist, researcher, or engineer desiring to accelerate some scientific application.
  • Many have noted the requirement of high-level development environments to speed acceptance of FPGA-augmented clusters.
  • These development tools accept a description of the application written in a high level language (HLL) and automate the translation of appropriate sections of code into hardware.
  • Hardware debugging and interfacing still must occur.
  • The use of automatic translation also drives up development costs compared to software implementations.

3.1. Nonstandard data formats

  • The use of IEEE standard floating-point data formats in hardware implementations prevents the user from leveraging an FPGA's fine-grained configurability, effectively reducing an FPGA to a collection of floating-point units with configurable interconnect.
  • Seeing the advantages of customizing the data format to fit the problem, several authors have constructed nonstandard floating-point units.
  • One of the earlier projects demonstrated a 23x speedup on a 2D fast Fourier transform (FFT) through the use of a custom 18-bit floating-point format [44] .
  • For the cost of their PROGRAPE-3 board, estimated at US$ 15,000, it is likely that a 15-node processor cluster could be constructed producing 196 single-precision peak GFLOPS.
  • Many comparisons spend significantly more time optimizing hardware implementations than is spent optimizing software.

3.2. GIMPS benchmark

  • The strength of configurable logic stems from the ability to customize a hardware solution to a specific problem at the bit level.
  • One such application can be found in the great Internet Mersenne prime search [50] .
  • The software used by GIMPS relies heavily on double-precision floating-point FFTs.
  • These memories operated concurrently, two of the buffers feeding the butterfly units while the third exchanged data with the external SDRAM.
  • In spite of the unique all-integer algorithmic approach, the stand-alone FPGA implementation only achieved a speedup of 1.76 compared to a 3.4 GHz Pentium 4 processor.

4. CONCLUSION

  • When comparing HPC architectures many factors must be weighed, including memory and I/O bandwidth, communication latencies, and peak and sustained performance.
  • As the recent focus on commodity processor clusters demonstrates, cost-performance is of paramount importance.
  • In order for FPGAs to gain acceptance within the general HPC community, they must be cost-competitive with traditional processors for the floating-point arithmetic typical in supercomputing applications.
  • The analysis of the costperformance of various current generation FPGAs revealed that only the lower-end devices were cost-competitive with processors for double-precision floating-point matrix multiplications.
  • For lower precision data formats current generation FP-GAs fare much better, being cost-competitive with processors.

Did you find this useful? Give us your feedback

Content maybe subject to copyright    Report

Hindawi Publishing Corporation
EURASIP Journal on Embedded Systems
Volume 2007, Article ID 93652, 8 pages
doi:10.1155/2007/93652
Research Article
Examining the Viability of FPGA Supercomputing
Stephen Craven and Peter Athanas
Bradley Department of Electrical and Computer Engineering, Virginia Polytechnic Institute and State University,
Blacksburg, VA 24061, USA
Received 16 May 2006; Revised 6 October 2006; Accepted 16 November 2006
Recommended by Marco Platzner
For certain applications, custom computational hardware created using field programmable gate arrays (FPGAs) can produce
significant performance improvements over processors, leading some in academia and industry to call for the inclusion of FPGAs
in supercomputing clusters. This paper presents a comparative analysis of FPGAs and traditional processors, focusing on floating-
point performance and procurement costs, revealing economic hurdles in the adoption of FPGAs for general high-performance
computing (HPC).
Copyright © 2007 S. Craven and P. Athanas. This is an open access article distributed under the Creative Commons At tribution
License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly
cited.
1. INTRODUCTION
Supercomputers have experienced a resurgence, fueled by
government research dollars and the development of low-
cost supercomputing clusters constructed from commodity
PC processors. Recently, interest has arisen in augmenting
these clusters with programmable logic devices, such as FP-
GAs. By tailoring an FPGAs hardware to the specific task at
hand, a custom coprocessor can be created for each HPC ap-
plication.
A wide body of research over two decades has repeat-
edly demonstrated significant performance improvements
for certain classes of applications through hardware accelera-
tion in an FPGA [1]. Applications well suited to acceleration
by FPGAs typically exhibit massive parallelism and small in-
teger or fixed-point data types. Significant performance gains
have been described for gene sequencing [2, 3], digital filter-
ing [4], cryptography [5], network packet filtering [6], target
recognition [7], and pattern matching [8].
ThesesuccesseshaveledSRCComputers[9], DRC Com-
puter Corp. [10], Cray [11], Star bridge Systems [12], and SGI
[13]tooer clusters featuring programmable logic. Cray’s
XD1 architecture, characteristic of many of these systems,
integrates 12 AMD Opteron processors in a chassis with six
large Xilinx Virtex-4 FPGAs. Many systems feature some of
the largest FPGAs in production.
Many HPC applications and benchmarks require double-
precision floating-point arithmetic to support a large dy-
namic range and ensure numerical stability. Floating-point
arithmetic is so prevalent that the benchmarking application
ranking supercomputers, LINPACK, heavily utilizes double-
precision floating-point math. Due to the prevalence of
floating-point arithmetic in HPC applications, research in
academia and industry has focused on floating-point hard-
ware designs [14, 15], libraries [16, 17], and development
tools [18]toeectively perform floating-point math on FP-
GAs. The strong suit of FPGAs, however, is low-precision
fixed-point or integer arithmetic and no current device fam-
ilies contain dedicated floating-point operators though ded-
icated integer multipliers are prevalent. FPGA vendors tai-
lor their products toward their dominant customers, driv-
ing development of architectures proficient at digital sig n al
processing, network applications, and embedded computing.
None of these domains demand floating-point performance.
Published reports comparing FPGA-augmented systems
to software-only implementations generally focus solely on
performance. As a key driver in the adoption of any new tech-
nology is cost, the exclusion of a cost-benefit analysis fails to
capture the true viability of FPGA-based supercomputing. Of
two previous works that do incorporate cost into the analy-
sis, one [19] limits its scope to a single intelligent network
interface design and, while the other [20] presents impres-
sive cost-performance numbers, details and analysis are lack-
ing. Furthermore, many comparisons in literature are inef-
fective, as they compare a highly optimized FPGA floating-
point implementation to nonoptimized software. A much

2 EURASIP Journal on Embedded Systems
Table 1: Published FPGA supercomputing application results.
Application Platform Format Speedup
DGEMM [21] SRC-6 DP 0.9x
Boltzmann [22]
XC2VP70 Float 1x
Dynamics [23]
SRC-6E SP 2x
Dynamics [24]
SRC-6E SP 3x
Dynamics [25]
SRC-6E Float 3.8x
MATPHOT [26]
SRC DP 8.5x
Filtering [27]
SRC-6E Fixed 14x
Translation [28]
SRC-6 Integer 75x
Matching [29]
SRC-6/Cray XD1 Bit 256x/512x
Crypto [30]
SRC-6E Bit 1700x
better benchmark would redesign the algorithm to play to
the FPGAs strengths, comparing the designs performance to
that of an optimized program.
The key contributions of this paper are the addition of an
economic analysis to a discussion of FPGA supercomputing
projects and the presentation of an eective benchmark for
comparing FPGAs and processors on an equal footing. A sur-
vey of current research, along with a cost-performance anal-
ysis of FPGA floating-point implementations, is presented in
Section 2. Section 3 describes alternatives to floating-point
implementations in FPGAs, presenting a balanced bench-
mark for comparing FPGAs to processors. Finally, conclu-
sions are presented in Section 4.
2. FPGA SUPERCOMPUTING TRENDS
This sect ion presents an overview of the use of FPGAs in su-
percomputers, analyzing the reported performance enhance-
ments from a cost perspective.
2.1. HPC implementations
The availability of high-performance clusters incorporating
FPGAs has prompted eorts to explore acceleration of HPC
applications. While not an exhaustive list, Table 1 provides
a survey of recent representative applications. The SRC-6
and 6E combine two Xeon or Pentium processors with two
large Virtex-II or Virtex-II Pro FPGAs. The Cray XD1 places
a Virtex-4 FPGA on a special interconnect system for low-
latency communication with the host Opteron processors.
In the table, the applications are listed by performance.
The abbreviations SP and DP refer to single-precision
and double-precision floating point, respectively. While the
speedups provided in the table are not normalized to a com-
mon processor, a trend is clearly visible. The top six examples
all incorporate floating-point arithmetic and fare worse than
the applications that utilize small data widths.
With no cost information regarding the SRC-6 or Cray
XD1 available to the authors a thorough cost-performance
analysis is not possible. However, as the cost of the FPGA ac-
celeration hardware in these machines alone likely is on the
order of US$10 000 or more, it is likely that the floating-point
examples may loose some of their appeal when compared to
processors on a cost-eective basis. The obser ved speedups
of 75–1700 for integer and bit-level operations, on the other
hand, would likely be very beneficial from a cost perspective.
2.2. Theoretical floating-point performance
FPGA designs may suer significant performance penalties
due to memory and I/O bottlenecks. To understand the po-
tential of FPGAs in the absence of b ottlenecks, it is instructive
to consider the theoretical maximum floating-point perfor-
mance of an FPGA.
Traditional processors, with a fixed data path width of
32 or 64 bits, provide no incentive to explore reduced pre-
cision formats. While FPGAs permit data path width cus-
tomization, some in the HPC community are loath to utilize
a nonstandard format owing to verification and portability
diculties. This principle is at the heart of the Top500 List
of fastest supercomputers [31], where ranked machines must
exactly reproduce valid results w hen running the LINPACK
benchmarks. Many applications also require the full dynamic
range of the double-precision format to ensure numeric sta-
bility.
Due to the prevalence of IEEE standard floating-point
in a wide range of applications, several researchers have de-
signed IEEE 754 compliant floating-point accelerator cores
constructed out of the Xilinx Virtex-II Pro FPGAs config-
urable logic and dedicated integer multipliers [3234]. Dou
et al. published one of the highest performance benchmarks
of 15.6 GFLOPS by placing 39 floating-point processing el-
ements on a theoretical Xilinx XC2VP125 FPGA [14]. Inter-
polating their results for the largest production Xilinx Virtex-
II Pro device, the XC2VP100, produces 12.4 GFLOPS, com-
pared to the peak 6.4 GFLOPS achievable for a 3.2 GHz Intel
Pentium processor. Assuming that the Pentium can sustain
50% of its peak, the FPGA outperforms the processor by a
factor of four for matrix multiplication.
Dou et al.s design is comprised of a linear array of MAC
elements, linked to a host processor providing memory ac-
cess. The design is pipelined to a depth of 12, permitting op-
eration at a frequency up to 200 MHz. This architecture en-
ables high computational density by simplifying routing and
control, at the requirement of a host controller. Since the re-
sults of Dou et al. are superior to other published results, and
even Xilinx’s floating-point cores, they are taken as a n abso-
lute upper limit on FPGAs double-precision floating-point
performance. Performance in any deployed system would be
lower because of the addition of interface logic.
Table 2 extrapolates Dou et al.s performance results for
other FPGA device families. Given the similar configurable
logic architectures between the dierent Xilinx families, it
has been assumed that D ou et al.s requirements of 1419
logic slices and nine dedicated multipliers hold for all fam-
ilies. While the slice requirements may be less for the Virtex-
4 family, owing to the inclusion of an MAC function with
the dedicated multipliers, as all considered Virtex-4 imple-
mentations were multiplier limited the overestimate in re-
quired slices does not aect the results. The clock frequency

S. Craven and P. Athanas 3
Table 2: Double-precision floating-point multiply accumulate
cost-performance in US dollars.
Device
Speed
(MHz)
GFlops
Device
cost
$/GFlops
xc4vlx200 280 5.6 $7010 $1,250
xc4vsx35
280 5.6 $542 $97
xc2vp100-7 200 12.4 $9610 $775
xc2vp100-6
180 11.2 $6860 $613
xc2vp70-6
180 8.3 $2780 $334
xc2vp30-6
180 3.2 $781 $244
xc3s5000-5 140 3.1 $242 $78
xc3s4000-5
140 2.8 $164 $59
ClearSpeed
CSX 600
N/A
50 [36] $7500 [37]
$150
Pentium 630 3000 3 $167 $56
Pentium D 920
2800 × 2 5.6 $203 $36
Cell processor
3200 × 910[38] $230 [39] $23
System X 2300 × 2200 12 250 [31] $5.8 M [40] $473
has been scaled by a factor obtained by averaging the perfor-
mance dierential of Xilinx’s double-precision floating-point
multiplier and adder cores [35] across the dierent families.
For comparison purposes, several commercial processors
have been included in the list. The peak performance for each
processor was reduced by 50%, taking into account compiler
and system ineciencies, permitting a fairer comparison as
FPGAs designs typically sustain a much higher percentage of
their peak performance than processors. This 50% perfor-
mance penalty is in line with the sustained performance seen
in the Top500 List’s LINPACK benchmark [31]. In the table,
FPGAs are assumed to sustain their peak performance.
As can be seen from the table, FPGA double-precision
floating-point performance is noticeably higher than for tra-
ditional Intel processors; however, considering the cost of
this performance processors fare better, with the worst pro-
cessor beating the best FPGA. In particular, Sony’s Cell pro-
cessor is more than two times cheaper per GFLOPS than the
best FPGA. The results indicate that the current generation of
larger FPGAs found on many FPGA-augmented HPC clus-
ters are far from cost competitive with the current genera-
tion of processors for double-precision floating-point tasks
typical of supercomputing applications.
With two exceptions, ClearSpeed and System X, all costs
in Table 2 only cover the price of the device not including
other components (motherboard, memory, network, etc.)
that are necessary to produce a functioning supercomputer.
It is also assumed here that operational costs are equiva-
lent. These additional costs are nonnegligible and, while the
FPGA accelerators would also incur additional costs for cir-
cuit board and components, it is likely that the cost of com-
ponents to create a functioning HPC node from a processor,
even factoring in economies of scale, would be larger than for
creating an accelerator plug-in from an FPGA. However, as
most clusters incorporating FPGAs also include a host pro-
cessor to handle serial tasks and communication, it is reason-
able to assume that the cost analysis in Ta ble 2 favors FPGAs.
To place the additional component costs in perspec-
tive, the cost-performance for Virginia Techs System X su-
percomputing cluster has been included [41]. Constructed
from 1100 dual core Apple XServe nodes, the supercom-
puter, including the cost of all components, cost US$473 per
GFLOPS. Several of the larger FPGAs cost more per GFLOPS
even without the memory, boards, and assembly required to
create a functional accelerator.
As the dedicated integer multipliers included by Xilinx,
the largest configurable logic manufacturer, are only 18-bits
wide, se veral multipliers must be combined to produce the
52-bit multiplication needed for double-precision floating-
point multiplication. For Xilinx’s double-precision floating-
point core 16 of these 18-bit multipliers are required [35]
for each multiplier, w hile for the Dou et al. design only nine
are needed. For many FPGA dev ice families the high multi-
plier requirement limits the number of floating-point multi-
pliers that may be placed on the dev ice. For example, while
31 of Dous MAC units may be placed on an XC2VP100, the
largest Virtex-II Pro device, the lack of sucient dedicated
multipliers permits only 10 to be placed on the largest Xilinx
FPGA, an XC4VLX200. If this dev ice was solely used as a ma-
trix multiplication accelerator, as in Dous work, over 80% of
the device would be unused. Of course this idle configurable
logic could be used to implement additional multipliers, at a
significant p erformance penalty.
While the larger FPGA devices that are prevalent in com-
putational accelerators do not provide a cost benefit for the
double-precision floating-point calculations required by the
HPC community, historical trends [42] suggest that FPGA
performance is improving at a rate faster than that of pro-
cessors. The question is then asked, when, if ever, will FPGAs
overtake processors in cost performance?
As has been noted by some, the cost of the largest cutt-
ing-edge FPGA remains roughly constant over time, while
performance and size improve. A first-order estimate of US$
8,000 has been made for the cost of the largest and newest
FPGA—an estimate supported by the cost of the largest
Virtex-II Pro and Virtex-4 devices. Furthermore, it is as-
sumed that the cost of a processor remains constant at
US$500 over time as well. While these estimates are some-
what misleading, as these costs certainly do vary over time,
the variability in the cost of computing devices between
generations is much less than the increase in performance.
The comparison further assumes, as before, that processors
can sustain 50% of their peak floating-point performance
while FPGAs sustain 100%. Whenever possible, estimates
were rounded to favor FPGAs.
Two sources of data were used for performance extrap-
olation to increase the validity of the results. The work of
Dou et al. [14], representing the fastest double-precision
floating-point MAC design, was extrapolated to the largest
parts in several Xilinx device families. Additional data was
obtained by extrapolating the results of Underwood’s histor-
ical analysis [42] to include the Virtex-4 family. Underwood’s

4 EURASIP Journal on Embedded Systems
2000 2002 2004 2006 2008 2010
10
100
1000
10000
Cost/GFLOPS ($)
Yea r
FPGAs
Processors
Extrapolation FPGA w/o Virtex-4
Extrapolation FPGA
Extrapolation processor
(a)
2000 2002 2004 2006 2008 2010
10
100
1000
10000
Cost/GFLOPS ($)
Yea r
FPGAs
Processors
Extrapolation FPGA w/o Virtex-4
Extrapolation FPGA
Extrapolation processor
(b)
Figure 1: Extrapolated double-precision floating-point MAC cost-
performance, in US dollars, for: (a) Underwood design and (b) Dou
et al. desig n.
data came from his IEEE standard floating-point designs
pipelined, depending on the device, to a maximum depth of
34. The results are shown in Figure 1(a) for the Underwood
data and Figure 1(b) for Dou et al.
An additional data point exists for the Underwood graph
as his work included results for the Virtex-E FPGAs. The
Dou et al. design is higher performance and smaller, in terms
of slices, than Underwood’s design. In both graphs, the lat-
est data point, representing the largest Virtex-4 device, dis-
plays worse cost-performance than the previous generation
of devices. This is due to the shortage of dedicated multipli-
ers on the larger Virtex-4 devices. The Virtex-4 architecture
is comprised of three subfamilies: the LX, SX, and FX. The
Virtex-4 subfamily with the largest devices, by far, is the LX
and it is these devices that are found in FPGA-augmented
HPC nodes. However, the LX subfamily is focused on logic
density, trading most of the dedicated multipliers found in
the smaller SX subfamily for configurable logic. This signifi-
cantly reduces the floating-point multiplication performance
of the larger Virtex-4 devices.
As the graphs illustrate, if this trend towards logic-centric
large FPGAs continues it is u nlikely that the largest FPGAs
will be cost eective compared to processors anytime soon,
if ever. However, as preliminary data on the next-generation
Virtex-5 suggests that the relatively poor floating-point per-
formance of the Virtex-4 is an aberration and not indica-
tive of a trend in FPGA architectures, it seems reasonable
to reconsider the results excluding the Virtex-4 data points.
Figure 1 trend lines labeled “FPGA extr apolation w/o Virtex-
4” exclude these potential misleading data points.
When the Virtex-4 data is ignored, the cost-performance
of FPGAs for double-precision floating-point matrix multi-
plication improves at a rate greater than that for processors.
While there is always a danger from drawing conclusions
from a small data set, both the Dou et al. and Underwood
design results point to a crossover point sometime around
2009 to 2012 when the largest FPGA devices, like those typ-
ically found in commercial FPGA-augmented HPC clusters,
will be cost eectively compared to processors for double-
precision floating-point calculations.
2.3. Tools
The typical HPC user is a scientist, researcher, or engineer
desiring to accelerate some scientific application. These users
are generally acquainted with a programming language ap-
propriate to their fields (C, FORTAN, MATLAB, etc.) but
have little, if any, hardware design knowledge. Many have
noted the requirement of high-level development environ-
ments to speed acceptance of FPGA-augmented clusters.
These de velopment tools accept a description of the appli-
cation written in a high level language (HLL) and automate
the translation of appropriate sections of code into hardware.
Several companies market HLL-to-gates synthesizers to the
HPC community, including impulse accelerated technolo-
gies, Celoxica, and SRC.
The state of these tools, however, as noted by some [43],
does not remove the need for dedicated hardware expertise.
Hardware debugging and interfacing still must occur. The
use of automatic translation also drives up development costs
compared to software implementations. C compilers and de-
buggers are free. Electronic design automation tools, on the
other hand, may require expensive yearly licenses. Further-
more, the added ineciencies of translating an inherently
sequential high-level description into a parallel hardware im-
plementation eat into the performance of hardware accelera-
tors.

S. Craven and P. Athanas 5
3. FLOATING-POINT ALTERNATIVES
3.1. Nonstandard data formats
The use of IEEE standard floating-point data formats in
hardware implementations prevents the user from le verag-
ing an FPGAs fine-g rained configurability, eectively reduc-
ing an FPGA to a collection of floating-point units with con-
figurable interconnect. Seeing the advantages of customizing
the data format to fit the problem, several authors have con-
structed nonstandard floating-point units.
One of the earlier projects demonstr ated a 23x speedup
on a 2D fast Fourier transform (FFT) through the use of a
custom 18-bit oating-point form at [44]. More recent work
has focused on parameterizible libraries of floating-point
units that can be tailored to the task at hand [4547]. By us-
ing a custom floating-point format sized to match the width
of the FPGAs internal integer multipliers, a speedup of 44
was achieved by Nakasato and Hamada for a hydrodynamics
simulation [48] using four large FPGAs.
Nakasato and Hamadas 38 GFLOPS of performance is
impressive, even from a cost-performance standpoint. For
the cost of their PROGRAPE-3 board, estimated at US$
15,000, it is likely that a 15-node processor cluster could be
constructed producing 196 single-precision peak GFLOPS.
Even in the unlikely scenario that this cluster could sus-
tain the same 10% of peak performance obtained by Naka-
sato and Hamadas for their software implementation, the
PROGRAPE-3 design would still achieve a 2x speedup.
As in many FPGA to CPU comparisons, it is likely that
the analysis unfairly favors the FPGA solution. Many com-
parisons spend significantly more time optimizing hardware
implementations than is spent optimizing software. Signif-
icant compiler ineciencies exist for common HPC func-
tions [49], with some hand-coded functions outperform-
ing the compiler by many times. It is possible that Nakasato
and Hamadas speedup would be significantly reduced, and
perhaps e liminated on a cost-performance basis, if equal
eort was applied to optimizing software at the assembly
level. However, to permit their design to be more cost-
competitive, even against ecient software implementations,
smaller more cost-eective FPGAs could be used.
3.2. GIMPS benchmark
The strength of configurable logic stems from the ability to
customize a hardware solution to a specific problem at the bit
level. The previously presented works implemented coarse-
grained floating-point units inside an FPGA for a wide range
of HPC applications. For certain applications the full flexibil-
ity of configurable logic can be leveraged to create a custom
solution to a specific problem, utilizing data ty pes that play
to the FPGAs strengths—integer arithmetic.
One such application can be found in the great Inter-
net Mersenne prime search (GIMPS) [50]. The software used
by GIMPS relies heavily on double-precision floating-point
FFTs. Through a careful analysis of the problem, an all-
integer solution is possible that improves FPGA performance
by a factor of two and avoids the inaccuracies inherit in
floating-point math.
The largest known prime numbers are Mersenne pri-
mes—prime numbers of the form 2
q
1, where q is also
prime. The distributed computing project GIMPS was cre-
ated to identify large Mersenne primes and a reward of
US$100,000 has been issued for the first person to identify
a prime number with greater than 10 million digits. The al-
gorithm used by GIMPS, the Lucas-Lehmer test, is iterative,
repeatedly performing modular squaring .
One of the most ecient multiplication algorithms for
large integers utilizes the FFT, treating the number being
squared as a long sequence of smaller numbers. The linear
convolution of this sequence with itself performs the squar-
ing. As linear convolution in the time domain is equivalent
to multiplication in the frequency domain, the FFT of the se-
quence is taken and the resulting frequency domain sequence
is squared elementwise before being brought back into the
time domain. Floating-point arithmetic is used to meet the
strict precision requirements across the time and frequency
domains. The software used by GIMPS has been optimized
at the assembly level for maximum performance on Pentium
processors, making this application an eec tive benchmark
of relative processor floating-point performance.
Previous work focused on an FPGA hardware implemen-
tation of the GIMPS algorithm to compare FPGA and pro-
cessor floating-point performance [51]. Performing a tradi-
tional port of the algorithm from software to hardware in-
volves the creation of a floating-point FFT on the FPGA.
On an XC2VP100, the largest Virtex-II Pro, 12 near-double-
precision complex multipliers could be created from the 444
dedicated integer multipliers. Such a design with pipelining
performs a single iteration of the Lucas-Lehmer test in 3.7
million clock cycles.
To leverage the advantages of a configurable architec-
ture an all-integer number theoretical transform was con-
sidered. In particular, the irrational base discrete weighted
transform (IBDWT) can be used to perform integer convo-
lution, serving the exact same purpose as the floating-point
FFT in the Lucas-Lehmer test. In the IBDWT, all arithmetic is
performed modulo a special prime number. Normally mod-
ulo arithmetic is a demanding operation requiring many cy-
cles of latency, but by careful selection of this pr ime num-
ber the reduction can be performed by simple additions and
shifting [51]. The resulting all-integer implementation incor-
porates two 8-point butterfly structures constructed with 24-
64-bit integer multipliers and pipelined to a depth of 10. A
single iteration of Lucas-Lehmer requires 1.7 million clock
cycles, a more than two-fold improvement over the floating-
point design.
The final GIMPS accelerator, shown in Figure 2 imple-
mented in the largest Virtex-II Pro FPGA, consisted of two
butterflies fed by reorder caches constructed from the inter-
nal memories. To prevent a memory bottleneck, the design
assumed four independent banks of double data rate (DDR)
SDRAM. Three sets of reorder buers were created out of
the dedicated block memories on the device. These mem-
ories operated concurrently, two of the buers feeding the
butterfly units while the third exchanged data with the ex-
ternal SDRAM. The final design could be clocked at 80 MHz

Citations
More filters
MonographDOI
10 Dec 2008
TL;DR: FPGA-based Implementation of Signal Processing Systems is an important reference for practising engineers and researchers working on the design and development of DSP systems for radio, telecommunication, information, audio-visual and security applications.
Abstract: Field programmable gate arrays (FPGAs) are an increasingly popular technology for implementing digital signal processing (DSP) systems. By allowing designers to create circuit architectures developed for the specific applications, high levels of performance can be achieved for many DSP applications providing considerable improvements over conventional microprocessor and dedicated DSP processor solutions. The book addresses the key issue in this process specifically, the methods and tools needed for the design, optimization and implementation of DSP systems in programmable FPGA hardware. It presents a review of the leading-edge techniques in this field, analyzing advanced DSP-based design flows for both signal flow graph- (SFG-) based and dataflow-based implementation, system on chip (SoC) aspects, and future trends and challenges for FPGAs. The automation of the techniques for component architectural synthesis, computational models, and the reduction of energy consumption to help improve FPGA performance, are given in detail. Written from a system level design perspective and with a DSP focus, the authors present many practical application examples of complex DSP implementation, involving: high-performance computing e.g. matrix operations such as matrix multiplication; high-speed filtering including finite impulse response (FIR) filters and wave digital filters (WDFs); adaptive filtering e.g. recursive least squares (RLS) filtering; transforms such as the fast Fourier transform (FFT). FPGA-based Implementation of Signal Processing Systems is an important reference for practising engineers and researchers working on the design and development of DSP systems for radio, telecommunication, information, audio-visual and security applications. Senior level electrical and computer engineering graduates taking courses in signal processing or digital signal processing shall also find this volume of interest.

215 citations

Book
19 Nov 2010
TL;DR: The introduction and the conclusion are the main chapters of the book, which provide a very strong theoretical and practical background to the field of reconfigurable computing, from the early Estrins machine to the very modern architecture like coarse-grained reconfigured device and the embedded logic devices.
Abstract: Introduction to Reconfigurable Computing provides a comprehensive study of the field Reconfigurable Computing. It provides an entry point to the novice willing to move in the research field reconfigurable computing, FPGA and system on programmable chip design. The book can also be used as teaching reference for a graduate course in computer engineering, or as reference to advance electrical and computer engineers. It provides a very strong theoretical and practical background to the field of reconfigurable computing, from the early Estrins machine to the very modern architecture like coarse-grained reconfigurable device and the embedded logic devices. Apart from the introduction and the conclusion, the main chapters of the book are Architecture of reconfigurable systems, Design and implementation, High-Level Synthesis for Reconfigurable Devices, Temporal placement, On-line and Dynamic Interconnection, Designing a reconfigurable application on Xilinx Virtex FPGA, System on programmable chip, Applications.

190 citations


Cites background from "Examining the viability of FPGA sup..."

  • ...In [57], Craven and Athanas provided a performace/price comparative study between FPGA-based high-performance computing machines and traditional supercomputers....

    [...]

  • ...Craven and Athanas recently provided in [57] a study on the viability of the FPGA in supercomputers....

    [...]

Proceedings ArticleDOI
05 Aug 2007
TL;DR: The machine itself - Maxwell - its hardware and software environment is described and very early benchmark results from runs of the demonstrators are presented.
Abstract: We present the initial results from the FHPCA Supercomputer project at the University of Edinburgh. The project has successfully built a general-purpose 64 FPGA computer and ported to it three demonstration applications from the oil, medical and finance sectors. This paper describes in brief the machine itself - Maxwell - its hardware and software environment and presents very early benchmark results from runs of the demonstrators.

124 citations

Proceedings ArticleDOI
24 Oct 2010
TL;DR: In this paper, a virtual reconfigurable architectures for different application domains, implemented on top of commercial off-the-shelf (COTS) devices, is proposed to hide the complexity of fine-grained physical devices and enable circuit portability across all devices that implement the intermediate fabric.
Abstract: Although hardware/software partitioning of embedded applications onto FPGAs is widely known to have performance and power advantages, FPGA usage has been typically limited to hardware experts, due largely to several problems: 1) difficulty of integrating hardware design tools into well-established software tool flows, 2) increasingly lengthy FPGA design iterations due to placement and routing, and 3) a lack of portability and interoperability resulting from device/platform-specific tools and bitfiles. In this paper, we directly address the last two problems by introducing intermediate fabrics, which are virtual reconfigurable architectures specialized for different application domains, implemented on top of commercial-off-the-shelf devices. Such specialization enables near-instantaneous placement and routing by hiding the complexity of fine-grained physical devices, while also enabling circuit portability across all devices that implement the intermediate fabric. When combined with existing work on runtime synthesis from software binaries, intermediate fabrics reduce the effects of all three problems by enabling transparent usage of COTS FPGAs by software designers. In this paper, we explore intermediate fabric architectures using specialization techniques to minimize area and performance overhead of the virtual fabric while maximizing routability and speedup of placement and routing. We present results showing an average placement and routing speedup of 554x, with an average area overhead of 10% and clock overhead of 18%, which corresponds to an average frequency of 195 MHz.

103 citations

Proceedings ArticleDOI
31 Aug 2010
TL;DR: It is shown that the GPU is more productive than the FPGA architecture for most of the benchmarks and it is concluded thatFPGA-based HPCS is being marginalised by GPUs.
Abstract: Heterogeneous or co-processor architectures are becoming an important component of high productivity computing systems (HPCS). In this work the performance of a GPU based HPCS is compared with the performance of a commercially available FPGA based HPC. Contrary to previous approaches that focussed on specific examples, a broader analysis is performed by considering processes at an architectural level. A set of benchmarks is employed that use different process architectures in order to exploit the benefits of each technology. These include the asynchronous pipelines common to "map" tasks, a partially synchronous tree common to "reduce" tasks and a fully synchronous, fully connected mesh. We show that the GPU is more productive than the FPGA architecture for most of the benchmarks and conclude that FPGA-based HPCS is being marginalised by GPUs.

61 citations


Cites methods from "Examining the viability of FPGA sup..."

  • ...FPGAs have been shown to effectively accelerate certain types of computation useful for research and modelling [2], [3], [4]....

    [...]

References
More filters
Proceedings ArticleDOI
22 Feb 2004
TL;DR: A novel linear-array string matching architecture using a buffered, two-comparator variation on the Knuth-Morris-Pratt (KMP) algorithm, proving the bound on the buffer size and running time, and providing performance comparisons against other approaches.
Abstract: Pattern matching for network security and intrusion detection demands exceptionally high performance. Much work has been done in this field, and yet there is still significant room for improvement in efficiency, flexibility, and throughput. We develop a novel linear-array string matching architecture using a buffered, two-comparator variation on the Knuth-Morris-Pratt(KMP) algorithm. For small (16 or fewer characters) patterns, it competes favorably with the state-of-the-art while providing better scalability and reconfiguration, and more efficient hardware utilization. The area efficiency compared to other approaches improves further still as the pattern size increases because only the tables increase in size.KMP is a well-known, efficient string matching technique using a single comparator and a precomputed transition table. We add a second comparator and an input buffer, allowing the system to accept at least one character in each cycle and terminate after a number of clock cycles at maximum equal to the length of the input string plus the size of the buffer. The system also provides a clean, modular route to reconfiguring the patterns on-the-fly and scaling the system to support more units, using several rows of linear array elements. In this paper, we prove the bound on the buffer size and running time, and provide performance comparisons against other approaches.

182 citations

Proceedings ArticleDOI
20 Apr 2004
TL;DR: The analysis highlights the amount of memory bandwidth and internal storage needed to sustain peak performance with FPGAs and considers the historical context of the last six years and is extrapolated for the next six years.
Abstract: Field programmable gate arrays (FPGAs) have long been an attractive alternative to microprocessors for computing tasks - as long as floating-point arithmetic is not required. Fueled by the advance of Moore's law, FPGAs are rapidly reaching sufficient densities to enhance peak floating-point performance as well. The question, however, is how much of this peak performance can be sustained. This paper examines three of the basic linear algebra subroutine (BLAS) functions: vector dot product, matrix-vector multiply, and matrix multiply. A comparison of microprocessors, FPGAs, and reconfigurable computing platforms is performed for each operation. The analysis highlights the amount of memory bandwidth and internal storage needed to sustain peak performance with FPGAs. This analysis considers the historical context of the last six years and is extrapolated for the next six years.

171 citations


"Examining the viability of FPGA sup..." refers methods in this paper

  • ...researchers have designed IEEE 754 compliant floating-point accelerator cores constructed out of the Xilinx Virtex-II Pro FPGA’s configurable logic and dedicated integer multipliers [16-18]....

    [...]

Book ChapterDOI
02 Sep 2002
TL;DR: A library of fully parameterized hardware modules for format control, arithmetic operations and conversion to and from any fixed-point format, and for hybrid implementations that combine both fixed and floating-point calculations.
Abstract: We present a parameterized floating-point library for use with reconfigurable hardware. Our format is both general and flexible. All IEEE formats are a subset of our format, as are all previously published floating-point formats for reconfigurable hardware. We have developed a library of fully parameterized hardware modules for format control, arithmetic operations and conversion to and from any fixed-point format. The format converters allow for hybrid implementations that combine both fixed and floating-point calculations. This permits the designer to choose between the increased range of floating-point and the increased precision of fixed-point within the same application. We illustrate the use of this library with a hybrid implementation of the K-means clustering algorithm applied to multispectral satellite images.

123 citations


"Examining the viability of FPGA sup..." refers background in this paper

  • ...More recent work has focused on parameterizible libraries of floating-point units that can be tailored to the task at hand [27-29]....

    [...]

Proceedings Article
17 Apr 2000
TL;DR: A JBits implementation of the Data Encryption Standard (DES) algorithm in a Virtex FPGA with a throughput of over 10 Gigabits per second, which exceeds the performance of a recently announced DES ASIC.
Abstract: A JBits implementation of the Data Encryption Standard (DES) algorithm in a Virtex FPGA is described. The Virtex architecture efficiently implements the DES primitive operations, and permits a high degree of pipelining. JBits provides a Java-base d Application Programming Interface (API) for the runtime creation and modification of the configuration bitstream. This allows dynamic circuit specialization based on a specific key and mode (encrypt or decrypt). The key schedule is computed entirely in software, and is part of the bitstream. As a result, all cryptographic key input and subkey generation logic are removed from the fully unrolled datapath. When combined with a speed efficient layout, the result is a throughput of over 10 Gigabits per second. This exceeds the performance of a recently announced DES ASIC.

118 citations


"Examining the viability of FPGA sup..." refers methods in this paper

  • ...Significant performance gains have been described for gene sequencing [2, 3], digital filtering [4], cryptography [5], network packet filtering [6], target recognition [7], and pattern matching [8]....

    [...]

Proceedings ArticleDOI
09 Apr 2003
TL;DR: The floating point unit generation approach outlined in this paper allows for the creation of a vast collection of floating point units with differing throughput, latency, and area characteristics.
Abstract: Most commercial and academic floating point libraries for FPGAs (field programmable gate arrays) provide only a small fraction of all possible floating point units. In contrast, the floating point unit generation approach outlined in this paper allows for the creation of a vast collection of floating point units with differing throughput, latency, and area characteristics. Given performance requirements, our generation tool automatically chooses the proper implementation algorithm and architecture to create a compliant floating point unit. Our approach is fully integrated into standard C++ using ASC, a stream compiler for FPGAs, and the PAM-Blox II module generation environment. The floating point units created by our approach exhibit a factor of two latency improvement versus commercial FPGA floating point units, while consuming only half of the FPGA logic area.

112 citations

Frequently Asked Questions (16)
Q1. What are the contributions in "Examining the viability of fpga supercomputing" ?

This paper presents a comparative analysis of FPGAs and traditional processors, focusing on floatingpoint performance and procurement costs, revealing economic hurdles in the adoption of FPGAs for general high-performance computing ( HPC ). 

The strong suit of FPGAs, however, is low-precision fixed-point or integer arithmetic and no current device families contain dedicated floating-point operators though dedicated integer multipliers are prevalent. 

One of the most efficient multiplication algorithms for large integers utilizes the FFT, treating the number being squared as a long sequence of smaller numbers. 

When comparing HPC architectures many factors must be weighed, including memory and I/O bandwidth, communication latencies, and peak and sustained performance. 

Many HPC applications and benchmarks require doubleprecision floating-point arithmetic to support a large dy-namic range and ensure numerical stability. 

to permit their design to be more costcompetitive, even against efficient software implementations, smaller more cost-effective FPGAs could be used. 

The distributed computing project GIMPS was created to identify large Mersenne primes and a reward of US$100,000 has been issued for the first person to identify a prime number with greater than 10 million digits. 

Floating-point arithmetic is so prevalent that the benchmarking application ranking supercomputers, LINPACK, heavily utilizes doubleprecision floating-point math. 

Due to the prevalence of floating-point arithmetic in HPC applications, research in academia and industry has focused on floating-point hardware designs [14, 15], libraries [16, 17], and development tools [18] to effectively perform floating-point math on FPGAs. 

For Xilinx’s double-precision floatingpoint core 16 of these 18-bit multipliers are required [35] for each multiplier, while for the Dou et al. design only nine are needed. 

A slightly reworked implementation, designed as an FFT accelerator with all serial functions implemented on an attached processor, could achieve a speedup of 2.6 compared to a processor alone. 

The availability of high-performance clusters incorporating FPGAs has prompted efforts to explore acceleration of HPC applications. 

The key contributions of this paper are the addition of an economic analysis to a discussion of FPGA supercomputing projects and the presentation of an effective benchmark for comparing FPGAs and processors on an equal footing. 

Performing a traditional port of the algorithm from software to hardware involves the creation of a floating-point FFT on the FPGA. 

In spite of the unique all-integer algorithmic approach, the stand-alone FPGA implementation only achieved a speedup of 1.76 compared to a 3.4 GHz Pentium 4 processor. 

While there is always a danger from drawing conclusions from a small data set, both the Dou et al. and Underwood design results point to a crossover point sometime around 2009 to 2012 when the largest FPGA devices, like those typically found in commercial FPGA-augmented HPC clusters, will be cost effectively compared to processors for doubleprecision floating-point calculations.