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.

© 1998-2014 BYTECODES