Get a Processor Matched Exactly to Your Algorithm
MATLAB is a great algorithm design tool that helps
engineers figure out if their algorithm is correct.
However, while the algorithm might be correct,
it might not be a good algorithm to implement in
hardware. Some algorithms are very efficient in
hardware, others are “hogs.” And often
it’s hard to see the hardware implications
of any algorithm or any change in an algorithm.
After all, most people working with MATLAB get
the algorithm to work on their 4 gigahertz Pentium
workstation. Then they want to try to get that
algorithm to work on a cell phone! The hardware
is a very important consideration.
Tensilica makes it easy. In embedded systems design,
many reference algorithms start off as C/C++ code,
and MATLAB/Simulink, which is used to design or
tune algorithms for implementation, can output
C code. Using our XPRES
Compiler, designers can
input this ANSI standard C or C++ code and, usually
in less than an hour, the XPRES Compiler will figure
out how to make an Xtensa LX processor that is
highly optimized to run that algorithm. The design
team benefits from having a hardware/software solution – not
just hardware that can’t be changed. Since
it’s a processor, changes in software are
easy to make, even after the silicon implementation
is finished.
XPRES Compiler quickly shows the tradeoffs of
various silicon
implementations. In graphical format,
the designer can quickly see different area/performance
trade-offs, as shown in the picture below.
In this case, for example, a performance of 12,000
cycles, achievable with 15,000 gates in addition
to the 25,000-gate base Xtensa LX processor, might
be all that’s required for the application.
As the designer then takes the design to the Xtensa
processor generator, the designer also gets valuable
information on power consumption to help make intelligent
implementation decisions before silicon.
We feel like we’re taking a unique approach – implementing
the hardware in a processor rather than hard-coded
gates – that has many advantages, especially
for complex algorithm implementations. After all,
standards often change. It’s much easier
to implement those changes in software than re-doing
the chip.
|
