Stretch today announced the S5000 family of software-configurable processors-the first to embed powerful programmable logic within an off-the-shelf processor-and a comprehensive suite of development tools that enable developers to automatically configure and optimize the processor using only their C/C++ code. Stretch’s software-configurable processors can be tailored quickly and easily to address compute-intensive applications in markets as diverse as consumer, telecommunications, networking, medical and military. Stretch’s S5000 software-configurable processors combine the best of two previously divergent semiconductor worlds-the ease of software development associated with GPPs (general-purpose processors) and DSPs, with the parallelism and flexibility of FPGAs. Stretch achieves this by embedding programmable logic entirely inside the processor architecture-an industry first.
Stretch today announced the S5000 family of software-configurable
processors-the first to embed powerful programmable logic within an
off-the-shelf processor-and a comprehensive suite of development tools that
enable developers to automatically configure and optimize the processor using
only their C/C++ code. Stretch’s software-configurable processors can be
tailored quickly and easily to address compute-intensive applications in markets
as diverse as consumer, telecommunications, networking, medical and military.
Stretch’s S5000 software-configurable processors combine the best of two
previously divergent semiconductor worlds-the ease of software development
associated with GPPs (general-purpose processors) and DSPs, with the parallelism
and flexibility of FPGAs. Stretch achieves this by embedding programmable logic
entirely inside the processor architecture-an industry first.
Every S5000 processor chip is powered by the Stretch(tm) S5 engine, which
incorporates the widely accepted Tensilica® Xtensa® RISC processor core and the
powerful Stretch Instruction Set Extension Fabric (ISEF). The ISEF is a
software-configurable data-path based on proprietary programmable logic. Using
the ISEF, system designers extend the processor instruction set and define the
new instructions using only their C/C++ code. As a result, developers get the
performance of logic with C/C++ development simplicity-achieving unprecedented
performance, easy and rapid development and significant cost savings.
The Need for a New Kind of Processor
Today, embedded system developers are forced to make painful compromises when
addressing compute-intensive applications. Their choices include using banks of
DSPs or GPPs, resulting in costly and difficult-to-program multiprocessor
systems; selecting fixed-function chips, which do not allow them to address
changing standards or differentiate their products; or mixing processors and
FPGAs or ASICs, which requires the design of custom hardware, greatly increasing
time-to-market and development costs.
"With the introduction of the Stretch S5000 family of software-configurable
processors, embedded system developers no longer need to trade-off performance,
time-to-market and system costs," said Gary Banta, Stretch CEO. "Developers
program and automatically configure our processors using pure C/C++, achieving
unprecedented performance, easy and rapid development, tremendous cost savings,
and the flexibility to address diverse markets and changing application needs."
Stretch: First Company to Embed Programmable Logic within a Processor
By embedding powerful programmable logic within a processor, Stretch has
uniquely combined the best qualities of GPPs, DSPs, ASPs (application-specific
processors), FPGAs and ASICs-creating an off-the-shelf processor chip that can
cost-effectively address virtually any compute-intensive application. With
Stretch’s new processors, embedded system designers can bypass painful
trade-offs between flexibility, performance, cost and time-to-market.
Stretch’s software-configurable processors and software development tools
provide significant breakthroughs and advantages:
Flexibility: For the first time, developers use C/C++ not only to program
the processor but also to create new instructions ideally matched to their
Stretch’s S5000 family of chips can be quickly tailored by the system developer
to address multiple markets and diverse applications.
Developers can respond to emerging standards, add new features and support new
algorithms-without starting their designs over from scratch.
Developers are able to "future-proof" their systems, building in support for
field upgrades to adjust to new standards, extend the life of their products,
and achieve greater product differentiation.
Performance: Conventional wisdom is that clock rate determines processor
performance—and that higher performance at the same clock rate requires complex
fixed-instruction-set architectures (e.g., VLIW, SIMD) that are difficult to
program and are effective only in certain applications. Stretch’s S5000 family
breaks new ground with configurable instructions that reduce program "hot spots"
(sequences of operations that must be repeated many times) into single
On conventional processors such as DSPs, optimization of hot spots is usually
done by a programmer using low-level assembly code, which directly represents
the sequence of processor operations one by one. Compilers automate this task,
but only with a significant loss in performance. Further, because each operation
is very simple, tens to hundreds of assembly instructions are needed to
implement each hot spot.
On a Stretch S5000 processor, an entire hot spot-expressed only in C/C++-is
reduced to a single instruction. First, the software developer identifies hot
spots using Stretch’s profiling tool. Then the C/C++ source code from the hot
spot is automatically compiled into an ISEF configuration, creating a single
custom instruction that implements the entire hot spot. Not only is this process
easy, but the performance gain can be huge: tasks that require tens to hundreds
of instructions on conventional processors becomes just one instruction on the
Working with system designers in fields as diverse as medical imaging, wireless
infrastructure and video conferencing, Stretch has consistently shown that the
Stretch S5000 processors far exceed the performance of today’s GPPs, DSPs, ASPs
and FPGAs. As a result, a single Stretch S5000 processor can typically replace a
bank of DSPs or GPPs, or a processor combined with one or more expensive FPGAs.
And due to its configurability, the Stretch S5000 can achieve this performance
on an extraordinarily wide range of applications-including applications in which
conventional processors do not perform well due to use of unusual data types or
Even in applications that represent the "home turf" of conventional processors,
Stretch has demonstrated huge performance advantages. With an EEMBC(r)
Telemark(tm) score of 877, the S5000 beats the most powerful DSP-enhanced GPPs
and DSPs on their home turf, as verified independently by the EEMBC
Stretch’s "home-field" is the replacement of banks of processors, or
processors plus FPGAs, with one S5000 processor and a simple C-compiler design
flow. Extraordinary performance is achieved without need for a complex and
time-consuming multi-chip, software and hardware development process. Stretch’s
processor-based development model ensures that the embedded system development
remains entirely in C/C++-slashing months from the development time.
Reduced Development and System Cost
Software-only development eliminates the high costs and problems associated
with hardware/software co-development, the cost of two development teams,
difficulty making bug fixes, inability to adjust to new standards and the very
long development cycle.
Replacing multiple DSPs or combinations of processors and FPGAs saves chip
costs, board space and development costs.
Product Specifications, Pricing and Availability
Stretch’s off-the-shelf S5000 software-configurable processor family debuts with
three members, all based on the S5 engine. The products differ only in their I/O
and packaging, allowing the products to even more precisely match the needs of
64b w/ ECC
|$ / AVAILABILITY||
$ 35 (25k)
$ 70 (10k)
$ 100 (10k)
Stretch’s solution also includes a complete suite of development tools,
run-time support and comprehensive documentation. An intuitive graphical
Integrated Development Environment ($ 900 single-user license) includes the
Stretch C Compiler, instruction-set simulator, profiler and debugger enabling
developers to port, profile, accelerate, and optimize applications quickly.
Run-time support includes a StretchBIOS toolkit of run-time code and MontaVista
Linux for embedded real-time Linux systems.