Implementing SAR Image Processing Using
Backprojection on the Cell Broadband Engine
William Lundgren l (wlundgren@gedae.com), Uttam Majumder2 (uttam.majumder@wpafb.af.mil),
Mark Backues3 (mark.backues@wpafb.af.mil), Kerry Barnes l (kbarnes@gedae.com),
James Steed l (jsteed@gedae.com)
1: Gedae, Inc., 1247 N. Church St., Suite 5, Moorestown, NJ 08057, phone: + 1 (856) 231-4458
2: Air Force Research Laboratory, Wright-Patterson Air Force Base, OH 45433, phone: + 1 (937) 674-9043
3: SET Corporation, 2940 Presidential Dr., Suite 270, Fairborn, OH 45324, phone: + 1 (937) 426-9401
Abstract-Many compute intense algorithms once deemed
impractical are now being found realizable on modern multicore
processors due to their massive compute power. An example of
such an algorithm is the backprojection method for synthetic
aperture radar (SAR) image processing. Backprojection provides
many benefits compared to the other method of SAR processing,
the polar format algorithm (PFA). This paper studies the
implementation of convolution backprojection (CBP) on the Cell
Broadband Engine™ (Cell/B.E.) architecture. The paper will
study how the implementation of CBP must be changed to deal
with the programming issues related to using the Cell/B.E.
processor. The programming issues that are studied include
partitioning the work across a heterogeneous set of processors
(SPEs and PPEs), managing the heterogeneous memories (small
local storage and large off-chip XDR memory), overlapping
processing with communication and read/writes from the XDR,
and optimizing the SPE and PPE code to highly utilize all ALU
paths. The Gedae programming language and multithreading
compiler is used to address these programming issues.
Performance of the CBP implementation on the Cell/B.E.
processor using Gedae is presented.
Index Terms- Cell Broadband Engine, SAR, Backprojection
I. INTRODUCTION
Many compute intense algorithms once deemed impractical
are now being found realizable on modern multicore
processors due to their massive compute power. An example
of such an algorithm is the backprojection method for
synthetic aperture radar (SAR) image processing.
Backprojection provides many benefits compared to the other
method of SAR processing, the polar format algorithm (PFA).
This paper studies the implementation of convolution
backprojection (CBP) on the Cell Broadband Engine™
(Cell/B.E.) architecture. The Cell/B.E. processor combines
one Power Processing Element (PPE) with 8 identical
Synergistic Processing Elements (SPE) [2]. The Cell/B.E.
processor is sufficiently powerful to tackle the CBP algorithm,
but many programming issues must be addressed to create an
implementation of CBP on the architecture. Because the PPE
provides relatively modest performance, the key to using the
Cell/B.E. processor efficiently is to take best advantage of the
SPEs. An SPE can process vector arithmetic very efficiently
because each processor has 4 SIMD ALU paths processing at
3.2GHz; however, each SPE has only 256KB of dedicated
1-4244-1539-X/08/$25.00 ©2008 IEEE
Authorized licensed use limited to: Carnegie Mellon Libraries. Downloaded on April 9, 2009 at 16:13 from IEEE Xplore. Restrictions apply.
local storage [2] for holding both instructions and data, which
requires manual management by the programmer.
The paper will study how the implementation of CBP must
be changed to deal with the programming issues related to
using the Cell/B.E. processor. The programming issues that
are studied include partitioning the work across a
heterogeneous set of processors (SPEs and PPEs), managing
the heterogeneous memories (small local storage and large off-
chip XDR memory), overlapping processing with
communication and read/writes from the XDR, and optimizing
the SPE and PPE code to highly utilize all ALU paths. The
Gedae programming language and multithreading compiler is
used to address these programming issues. Performance of the
CBP implementation on the Cell/B.E. processor using Gedae
is presented.
II. BACKPROJECTION
The two most common algorithms for SAR image
processing are the polar format algorithm (PFA) and
backprojection.Data collected by SAR systems is called
Fourier space or K-space data and resides on an annular grid
[1]. K-space data is related to image data through the Fourier
transform. Therefore, to form an image, a 2D FFT is applied
to the K-space data. However, before applying the 2D FFT,
an FFT based imaging method (such as PFA) needs to inscribe
a rectangular grid within the annular region. This is called
polar-to-rectangular (Cartesian) coordinate conversion of K-
space data and is accomplished by applying a 2D interpolation
on the K-space data. Two major drawbacks of the PFA are:
(1) all radar data must be available from the sensed scene to
apply polar to rectangular conversion, and (2) interpolation
inaccuracy leads to degraded image quality. Backprojection
image formation uses K-space data directly and does not
require polar to rectangular conversion. In addition, all radar
data need not be available from the sensed scene to start the
image formation process. Further, the quality of images
formed by backprojection is superior to that of the PFA.
The backprojection algorithm was conceived in the field of
computer-aided tomography (CAT). Later, it was found that
SAR image reconstruction is mathematically similar to CAT
and researchers developed backprojection for SAR [1][3 ].
Two variations of backprojection are found in literature:
convolution backprojection (CBP) and backprojection filtering
(BpjF)[5]. Some papers refer to CBP as filtered
backprojection (FBP) or factored backprojection (FBP) [4].
In CBP, convolution with a kernel function is accomplished on
each projection. The result is then backprojected to a grid.
In the BpjF method, first the projections are backprojected
on an image grid. Then the backprojected image is filtered.
This filtering process in BpjF introduces image reconstruction
inaccuracy [5]. Hence CBP is the preferred method for
backprojection.
III. CELL BROADBAND ENGINE ARCHITECTURE
The current implementation of the Cell Broadband Engine
(Cell/B.E.) processor combines one Power Processing Element
(PPE) with 8 identical Synergistic Processing Elements (SPE).
The PPE is a dual-threaded PowerPC core with an instruction
set that has been extended to include SIMD (Single-
Instruction, Multiple-Data) instructions known as VMX. Each
SPE contains a high-speed SIMD processor with its own 256
kB local store and DMA engine. The nine cores and the on-
chip memory controller and I/O controller are interconnected
with the high speed Element Interconnect Bus (EIB) as shown
in Figure 1. The EIB provides a measured peak bandwidth of
over 200 GB/s at 3.2 GHz. [2]
Because the PPE provides relatively modest performance,
the key to using the Cell/B.E. processor efficiently is to take
best advantage of the SPEs. While an SPE can process vector
arithmetic very efficiently, each SPE has only 256 kB of
dedicated local storage which holds both instructions and data.
Thus when processing a large data set, the developer must
either distribute the large data set across the processing cores
or store the data in off-chip system memory. For instance, an
entire Ik-by-Ik complex matrix cannot reside in the SPE local
storage, even if the program size is zero. Therefore large data
sets will initially reside in system memory, and then the
developer will strip-mine the data, bringing it chunk-by-chunk
to the SPE local storage for processing.
SPE
Figure 1 - The current CelllB.E. Processor combines a PPE
core with 8 SPE cores, all interconnected via a high-speed
bus.
Authorized licensed use limited to: Carnegie Mellon Libraries. Downloaded on April 9, 2009 at 16:13 from IEEE Xplore. Restrictions apply.
IV. ALGORITHM
Gedae is used to implement the CBP algorithm on the
Cell/B.E. processor. Figure 2 shows the geometry of the
problem. It assumes that the RADAR is flying in a circle
surrounding the center of the area to be imaged. The goal of
this process is to partition the data such that it fits in the SPEs.
We start by showing the symbolic expressions for the
backprojection algorithm and then reconstruct them to show
the expressions that can be deployed in the SPEs. The
expression syntax used makes it easy to express the data
reorganization required to fit the data into SPE fast local store.
Figure 2 - The RADAR is flown in a circle with RADAR
always pointing in approximate direction of center of the
region of interest.
The range variables (see appendix) that we need to define
the algorithm are
p = O.. Npulses-l
fO = O.. NrngGates-l
f = O.. 4*NrngGates-l
xi = O.. X-l /* the x image indices */
yi = O.. Y-l /* the y image indices */
where we will form an image with x*y pixels, Npulses is the
number of pulses used to form an image, and NrngGates is the
number of samples collected for each pulse. We also have 3
parameters
OF = delta frequency between range bins
C40F = C/4/0F a convenient constant
(x[xi], y[yi]) = location of the (xi,yi) pixel
where C is the speed of light. The pixel location in the image
is calculated based on parameters set by the user.
The inputs to the algorithm are the RADAR returns and
several parameters that define the state of the system. The
RADAR data is given as:
in[p] [fO]
where p and fO are defined above. The location of the
RADAR at the time it is pulsed is:
(xobs [p], yobs [p], zobs [p] )
So there are p observations points, one for each pulse in the
data set. . We also have the range of the first range bin from
the RADAR. That is, the RADAR is pulsed and then the
analog to digital conversion starts a little later and so the first
range bin is some distance away from the observation point. It
is given by:
 rstart[p] = range of the first range bin in the
RADAR return
The pulse compresssion is computed by windowing, zero
filling the input data then computing the FFT.
inl [p] [f] = 0.0
inl[p] [fO] = in[p] [fO]*W[fO]
in2[p] [] = ifft(inl[p] [])
where W[] is the windowing vector. The range is computed as
follows:
rng [p] [yi] [xi] = sqrt ( (xobs [p] -x [xi] ) "2 +
(yobs[p]-y[yi])"2 + zobs[p]"2)
where xobs[], yobs[] and zobs[] is the location of the RADAR
when it is pulsed for pulse p, and x and yare the locations of
the image pixels in the x,y coordinate system. The phase delta
of the signal due to the round trip time from the RADAR to the
image pixel and back is given by:
dphase[p] [yi] [xi] = exp(i*4*PI/C*fO[p])*
rng [p] [yi] [xi]
The range of the return from the pixel at (xi,yi) in units of bin
indices is given by:
rbin[p] [yi] [xi] = Nbins * (rng[p] [yi] [xi] -
rstart[p]) / 2 / C4DF
where rstart[] is the distance of the first range bin from the
from the RADAR. The range bin index is given by
irbin [p] [yi] [xi] = floor (rbin [p] [yi] [xi])
The weights used for linear interpolation are
wI [p] [yi] [xi] = rbin [pJ [yi] [xi] - irbin [pJ [yiJ [xiJ
wO [pJ [yi] [xi] = 1 - wI [pJ [yiJ [xi]
The output image is the accumulation of phase adjusted returns
from the appropriate bin. If the phases match, then the value
will be reinforced. The computation is:
out[yiJ [xiJ +=
in2 [p] [irbin [p] [yiJ [xiJ ] *wO [pJ [yiJ [xiJ +
in2 [pJ [irbin [pJ [yiJ [xiJ +IJ *wl [pJ [yiJ [xiJ) *
dphase[p] [yiJ [xi]
V. IMPLEMENTATION
To allow the implementation to run on the SPEs of the
Cell/B.E. processor, we must consider how much data can fit
into memory at one time. In order to complete the
computation we need to have 7 matrices - the range matrix,
Portion of
the pulse
required for
this tile
Figure 3 - We will process a tile at a time. The tile shown is
representative of the tiles that completely cover the area. It is
apparent that only a small portion of the pulse return is used
to compute the backprojection.
Authorized licensed use limited to: Carnegie Mellon Libraries. Downloaded on April 9, 2009 at 16:13 from IEEE Xplore. Restrictions apply.
delta phase matrix, floating point and integer copies of the
range bin matrix, 2 weighting matrices and an output matrix -
in memory. These matrices require
(6*4*X*Y+8*X*Y)*Npulses bytes of data since 6 of the
matrices are floating point or integer and the other is complex.
We also need the input data in memory. Since the input data is
complex it is 8*4*NrngGates*Npulses bytes, the total memory
required is 32*X*Y+32*NrngGates bytes of data. Even if X,
Y, Npulses and NrngGates are only 1024, the requirement is
for>32 Gbytes of memory. Since all the data cannot fit into
memory, we must do one pulse and one tile of the image at a
time. As it turns out - this decomposition of the image means
that we have to bring in only a subvector of in2[p] for each
pulse / tile combination - further limiting the memory
requirements.
Since there is not enough local store memory on the SPEs to
hold all the data we need, we will have to process a single tile
of the image at a time. Figure 3 shows the geometry of only
one tile from the area of interest.
We define the structure of the algorithm by defining how the
output image will be decomposed for processing. We will
leave it to the reader to substitute the same decomposition in
the range related arrays required to complete the
implementation.
We define several new ranges to define the decomposition
of the processing. We have first divided the y index to
distribute on the SPEs and then divided further for stream
processing of the tiles. Since there are multiple SPEs for
processing we define a range variable for the number of
processors:
proc = O.. Nprocs-l
where Nprocs in our case will be 8. We will decompose the
output image (matrix) into tiles. The new y indices are given
by:
yi2 = 0 .. Y2-1
where Nprocs*Y2 = Y and
yi = proc*Y2 + yi2
and equivalently
[yiJ = [proc,yi2J
In this first step of the decomposition we only decompose for
the processors. Notice that throughout this decomposition we
specify the decomposition of the left hand side of the equation
and then propagate that decomposition to the right hand side.
We leave the indices of the weighting array out to simplify the
expressions. So the output:
out [yi] [xi] += in2 [pJ [irbin [pJ [yiJ [xiJ ] *wO +
in2 [pJ [irbin [pJ [yiJ [xiJ +1] *wl) *
dphase[pJ [yiJ [xiJ
can be rewritten using the comma notation as:
out[proc,yi2J [xiJ+=
in2[pJ [irbin[pJ [proc,yi2] [xi]]*wO +
in2[p] [irbin[p] [proc,yi2J [xi]+I]*wl)*
dphase (p) [proc, yi2] [xi]
and then reorganized as a family of submatrices (henceforth
tiles) one for each processor:
[proc]out[yi2] [xi]+=
in2 [p] [[procJ irbin[pJ [yi2] [xi]] *wO +
in2[pJ [[proc]irbin[p] [yi2] [xi]+I]*wl)*
[procJdphase[p] [yi2] [xi]
The pre-index indicates that there is a family of sub-images
one for each SPE We define the additional range variables:
 xiO 0 .. XO-I
xiI 0 .. XI-I
yiO 0 .. YO-I
yil 0 .. YI-I
where XO*XI = X and YO*YI = Y2. We will use these ranges
to reorganize the tiles on each processor into smaller tiles that
can be streamed from system memory into local memory. That
is, converting to comma notation:
[proc]out[yiO,yil] [xiO,xiI]+=
in2 [p] [ [proc] irbin [p] [yiO, yiI] [xiO, xiI] ] *wo +
in2 [p] [[proc] irbin[p] [yiO,yiI] [xiO,xiI]+l] *wI) *
[proc]dphase[p] [yiO,yiI] [xiO,xiI]
If we fix proc, p, yiO and xiO then are looking at a single tile of
the matrix and the token size is yi 1*xi 1 elements. We move
them into memory one at a time to reduce memory
requirements. To represent this tiling we will change the slow
moving (left most) indices into streams indices - specifying
that individual tiles will be processed in sequence.
[proc] out (yiO, xiO) [yiI] [xiI] +=
in2 (p) [ [proc] irbin (p, yiO, xiO) [yiI] [xiI]] *wo +
in2(p) [[proc]irbin(p,yiO,xiO) [yiI] [xiI]+l]*wI)*
[proc] dphase (p, yiO, xiO) [yiI] [xiI]
Since the pulse is the slow moving index and we are
accumulating over that index it means we have to move output
tiles into and out of memory with each iteration. This tile
movement will stress the memory bandwidth and limit
throughput. To address this issue, we reorder the indices so
that the fast moving index is the pulse and so we process all
pulses for a tile of the image before proceeding to the next tile. Figure 4 - Execution trace for processing of a single tile. The
This reordering describes a transpose but rather than actually functions that take the longest are the complex exponent and
transpose the data in system memory, a costly operation, we extracting the range bin from the input data.
will just read/write the data from/to system memory in non- rng (yiO, xiO, p) [yiI] [xiI] = sqrt ( (xobs (p) -
contiguous order. Since we can fit the output tile into memory, x (xiO) [xiI]) "2 + (yobs (p) -y (yiO) [yiI]) "2 +
zobs(p)"2)
we sum into that tile while processing the pulses and then
Weare now streaming all of the data into the local stores to
move it into system memory at the end of the processing. This
minimize memory use.
approach minimizes the movement of data to and from system
The result of this reorganization and streaming is the
memory. In the following equation we reorganize the tiles into
requirement that we store 7 matrices in memory each with
the appropriate stream order to process all pulses of one tile in
Yi 1*Xi 1 data elements, as well as the input matrix with
sequence:
[proc] out (yiO, xiO) [yiI] [xiI] += 4*NrngGates inputs. Since the input matrix and one of the 7
in2 (p) [ [proc] irbin (yiO, xiO, p) [yiI] [xiI]] *wo + other matrices are complex data, we will have a total of
in2(p) [[proc]irbin(yiO,xiO,p) [yiI] [xiI]+l]*wI)* 6*4*Yil *Xil+8*Yil *Xil+8*4*NrngGates or
[proc] dphase (yiO, xiO, p) [yiI] [xiI]
32*Yil *Xil+32*NrngGates bytes of memory. If we limit the
This ordering minimizes the movement of data from local
memory used for the 7 range related matrices to about 100
store into system memory. We combine the move with the
insert into the output image. =
Kbytes then Yi 1*Xi 1 3200. So Xi 1 and Yi 1 are limited to
about 56. This restriction allows us to easily fit a tile size of 32
We also note that we are now only using a tile of the weight
by 32, a size sufficiently large to exploit the SPE's SIMD
array at a time and a tile of irbin. To do this processing most
ALU resource.
efficiently we apply the same re-ordering to those data items
and arrive at the following:
rbin(yiO,xiO,p) [yiI] [xiI] = Nbins * VI. RESULTS
(rng(yiO,xiO,p) [yiI] [xiI] - rstart(p)) / 2 /
C4DF For purposes of our timing, we have chosen X, Y, Npulses
and and NrngGates to the same value and used values of 256, 512,
wI (yiO,xiO,p) [yiI] [xiI] 1024 and 2048. The processing time for each experiment is
rbin(yiO,xiO,p) [yiI] [xiI] - shown in table 1.
irbin(yiO,xiO,p) [yiI] [xiI]
wO (yiO,xiO,p) [yiI] [xiI] = 1 - A Trace Table of the processing required for 1 pulse and 1
wI(yiO,xiO,p) [yiI] [xiI] tile is shown in figure 4. In the Trace Table, each row lists a
These quantities are derived from dphase, and the x and y grid different function in the algorithm, and black bars indicate the
locations. We extend the streaming to those quantities as well: duration of the execution of the kernel. Notice that 3
dphase (yiO,xiO,p) [yiI] [xiI] = exp (i*4*PI/C*fO [p] *
rng(yiO,xiO,p) [yiI] [xiI]
functions' execution time are significantly longer than the
and other functions' times, the mz_exp function and two instances
of the vz vi scatter function.

Authorized licensed use limited to: Carnegie Mellon Libraries. Downloaded on April 9, 2009 at 16:13 from IEEE Xplore. Restrictions apply.
 The mz_exp function implements the complex exponential
function, a transcendental function which is by nature slow.
Optimized vector routines are used in the functions to take
advantage of the SPE's 4-wide SIMD ALU. The mz_exp
function uses such a routine and the performance is much
better than vanilla C code. Other implementations and
approximations of the exponential were considered as
optimizations. We considered replacing the mz_exp function
with a table lookup but because the time of the vectorized
exponential is approximately the same as the other table
lookups there is little value to be gained by such an
experiment.
The vz_vi_scatter function (2 copies) is slow because the
function is basically a table lookup - a function not
particularly suited for speedup on an SPE due to the
processor's reliance on memory alignment in both input and
output memory. No vector function is readily available for the
SPE to perform this operation. Some speedup was achieved
by using SPE intrinsics (the C interface to the SPE's assembly
language) in the function. The hand-optimized function does
the pointer arithmetic in the table lookup using the SIMD
ALU, and uses other intrinsics for extracting and loading
values into the quad word vector data structure.
An additional optimization was required to achieve high
performance on the v_outerAdd function. This function
calculates the equation
out[i] [j] = a[i] + b[j]
This function can be implemented as R calls to the vector
routine that performs a scalar-by-vector add, however the
small row-size of the matrix tiles leads to a high overhead in
filling and emptying the pipeline for each row. To avoid this
inefficiency, the function was hand-coded using SPE intrinsic
to perform all 1024 additions without emptying the pipeline.
There was initial concern that the square root function
would need to be approximated in order to achieve high
performance. However the sqrt vector routine used in the
implementation is efficient, and there is little value to
replacing that function with an approximation.
Table 1 shows the expected number of pulses. Ifwe assume
a PRF of 0.1 mSec the number of processors required is
(Time/Pulse) / (0.1) and is shown in the fourth row of table 1.
A practical implementation is likely to only process sub
regions after the data has been decimated. Because practical
implementations may vary, we cannot make a general
statement here. For the implementation presented, we can say
that the number of processors required is approximately:
Np = 2e-6 * X * Y / PRF
where X and Yare the number of pixels in the region to be
imaged, PRF is the pulse repetition frequency and Np is the
number of Cell/B.E.s required for a real-time implementation.
Npulses 256 512 1024
Time (mSec) 35.7 285.1 2,368.8
Time / Pulse (mSec) 0.139 0.557 2.313
# ofCell/B.E. Rqrd 2 6 24
Table 1 - The timing results running on a QS20 blade server
from IBM. The second row is the time to process a single
RADAR pulse. If we assume a PRF of 10 Khz then the third
row is the number of CelllB.E. processors required.
Authorized licensed use limited to: Carnegie Mellon Libraries. Downloaded on April 9, 2009 at 16:13 from IEEE Xplore. Restrictions apply.
VII. CONCLUSIONS
Gedae makes the complex implementation required to
implement these algorithms on the Cell/B.E. architecture
practical. The advent of high performance multicore hardware
makes implementation of backprojection possible, and the use
of Gedae to program these new architectures makes the
implementation more easily achievable.
REFERENCES
[1] Desai, Mita D. and W. Kenneth Jenkins. ·"Convolution
Backprojection Image Reconstruction for Spotlight Mode
Synthetic Aperture Radar." IEEE Transactions on Image
Processing, 1(4), October 1992.
[2] IBM, Sony Computer Entertainment, Toshiba. Cell Broadband
Engine Programming Handbook, Version 1.1, April 2007.
<http://www.ibm.com>.
[3] Jain, Anil K. Fundamentals of Digital Image Processing.
Prentice Hall, NJ, 1989.
[4] Ulander, Lars M.H., Hans Hellsten, and Gunnar Stenstroem.
··Synthetic-Aperture Radar Processing Using Fast Factorized
Back-Projection." IEEE Transactions on Aerospace and
Electronic Systems, 39(3), July 2003.
[5] Zeng, Gengsheng L. and Grant T. Gullberg. "·Can the
Backprojection Filtering Algorithm be as Accurate as the
Filtered Backprojection Algorithm?" Proceedings of Nuclear
Science Symposium and Medical Imaging Conference, volume
3. Institute of Electrical and Electronics Engineers (IEEE),
October 1994.
APPENDIX: SYMBOLIC EXPRESSIONS
The code segments shown in this document are created
using Gedae symbolic expressions. In these expressions,
ranges are used to express iteration over dimensions. For
example, a vector add
out[i] = a[i]+b[i]
is specified in C code as
for (i=O; i<N; i++) out[i] = a[i]+b[i];
and can be specified by the pair of symbolic expressions
i=O .. N-l
out[i] = a[i]+b[i]
Data is assumed to be part of an infinite data stream, which
allows the expressions to iterate over time, as well as, space.
In addition to array dimensions specified by square brackets
("'["' and "']"), data can be grouped temporarily using
parentheses ("'("' and "')"). For example, a vector to matrix
conversion can be specified as the temporal grouping of R
vectors in a stream
i=O .. R-l
j=O .. C-l
out [i] [j] = in (i) [j]
Note that the indices the time dimension is the slower moving
dimension, and therefore is listed to the left of the array index.
Data reorganization can be specified not just between
2048 indices but also within a single index by using the comma
18,259.4 notation. For example, to transpose the elements in a I-d
8.916 vector of length N
90 i=O .. R-l
j=O .. N/R-l
out [j, i] = in [i, j]
Collapsing operators can be used to perform operations
where the index being iterated over disappears in the output
array, such as a vector sum of elements
 i=O .. N-l
out += in[i]
The collapsing operators are similar to C for-loops where
the initial value is set to a default value, such as zero for "+="
and one for "*=". The for-loop is formed from the collection
of all indices specified on the right hand side of the equation
that are absent from the left hand side.

Authorized licensed use limited to: Carnegie Mellon Libraries. Downloaded on April 9, 2009 at 16:13 from IEEE Xplore. Restrictions apply.