Significantly
Higher Speed
EBCI Interpreters are built
using proprietary techniques and algorithms that produce the
shortest code path lengths possible and thus the fastest
execution time. Unique code generation tools do things such
as schedule instructions into least used cache lines, an
advantage which yields 28% faster Java execution in one of
our interpreter versions. And this is just one of the many
specialized optimizations we do.
Games
Sizzle with 3.5 Times Faster Floating-point Emulation
Our Floating-point routines are
so optimized that they run over three times faster than the
'C' library routines used by other engines. For maximum
performance our floating-point emulation code resides
directly in-line inside the interpreter instead of being
called as subroutines or OS traps. This avoids calling
overhead and entirely eliminates the need to save and
restore register contexts. In fact, our total bytecode
execution time for integer to float conversions is less than
just the function calling overhead required by JITs and
hardware accelerators to do their arithmetic. We execute
these operations six times faster than the competition.
Java
Based Graphics Rendering 4.5 Times Faster
Systems and applications with
graphics routines coded directly in Java can experience 4.5
times faster drawing speed. This is especially important for
games and applications which need to do specialized
rendering that is unavailable from the preinstalled lower
level graphics primitives. More
Minimal
Memory Footprint
Bytecodes' proprietary algorithms
have the unusual property of offering significant speed
while only adding 8K to 24K bytes to the total system
footprint. In fact, our interpreter working set (the
typically active executing code) is only 3K bytes which
means the interpreter itself usually runs completely in
microprocessor on-chip cache!
No
Battery Draining Extra Circuitry
Some Java accelerators are
hardware based, but just adding 10 milliwatts to a cell
phone's power requirements reduces its talk standby time by
half! Our EBCI technology is totally software based.
Java applications run faster and in less time so battery
life improves.
Real-time
Not Blocked by Translation Overhead
Acceleration techniques such as
Just-In-Time Compilers (JITs) force system stalls when code
translation kicks in causing slow startup and widely
inconsistent system response times. EBCI technology
does not use translation so startups are faster and
real-time response always quick and reliable. CPU benchmark
times rarely vary by more than 0.5
percent.
Executes
Real Java Applications at JIT Speeds
Most embedded platforms have
either limited memory or processors with small on-chip
caches. JIT technology encounters significant performance
problems in these environments due to cache and buffer
thrashing. In limited memory situations the JIT runs out of
translation buffers. And if the platform microprocessor
offers less than 64K of on-chip instruction cache then
constant cache refills occur. Either of these events consume
valuable processor time and degrade system performance.
EBCI technology uses no code translation buffers so is
immune to these slowdowns. The working set of the
interpreter itself fits into only 3K and runs entirely in
microprocessor cache. Speed never diminishes and execution
time is consistent. Our interpreters run complicated Java
code, like web browsers, at JIT performance levels as
demonstrated on actual customer platforms.
No
JIT Required but Complements One if Present
Embedded systems having large
enough memories and processor caches to support a JIT still
benefit by including an EBCI interpreter. This is
because class files not yet targeted for compiling, or too
big to compile, must be interpreted, especially when
adaptive compilation techniques are used. Having a fast
interpreter improves system startup time as well as overall
performance even when a JIT is present.
Passes
Java Bytecode Compliance Tests
Due to the complexity of our
technology Bytecodes has its own extensive test and
validation suite which consists of over 110,000 lines of
code. In fact, the tests are so comprehensive that we have
uncovered significant errors in other Java interpreters that
have been "certified" as correct by other validation suites.
Our bytecode validation consists of successfully executing
over 20 million dynamically generated Java programs and the
Floating-point emulation validation portion alone typically
takes 10 days to run. Due to this high quality stringent
validation, customer integrated EBCI interpreters have
passed every attempted third-party virtual machine bytecode
conformance test without failure.
More
Multiple Variants
to Choose From
Bytecodes' unique interpreter
compilation system permits a variety of interpreter
variations and sizes to be generated. Use any selection
process to choose the variant that best fits your platform.
For example, our J2ME CLDC interpreters come in three
different sizes, each offering you a different speed versus
size tradeoff.
|