Java solutions for embedded applications

Java has gained popularity in embedded applications, due to it providing a "safe environment" for user-applications and forming a foundation of a cross-platform abstraction and execution layer.

Overview

Theobroma Systems offers an embedded Java virtual machine with just-in-time compiler for a variety of platforms. While we currently focus our standard product on UNIX-like operating systems, support for other operating systems will be added on demand. Our solution excels through its extensive list of supported instruction set architectures: MIPS, PowerPC, ARM, Coldfire, x86, AMD64, SPARC and AXP.

The requirements for Java solutions in embedded systems can be split into a number of categories, each posing specific challenges to Java VM implementors:

• high-performance or high-throughput
  Most embedded Java virtual machines target mobile and resource constrained applications. However, the overwhelming majority of embedded Java solutions sacrifices performance for a reduction in footprint.
  Theobroma Systems offers high-performance Java execution for embedded systems: the just-in-time compiler is an integral part of our virtual machine and supported on all platforms. This provides the necessary performance, even for compute-intensive Java workloads.
• deeply embedded & resource-constrained
  Deeply embedded and resource-constrained applications mainly focus on a reduction in footprint.
  Most frequently, the just-in-time compiler is not needed and left off to reduce the memory footprint. However, our just-in-time compiler is efficient enough to fit even into highly constrained environments and to accelerate Java execution everywhere.
• high assurance applications
  High-assurance application environments require fault-containment within the Java environment and may have strict certification and audit requirements for the used software modules.
  Through our compatibility with the GNU Classpath runtime libraries, we can offer support for an open-source Java-compatible runtime environment. Depending on the application, a subset of the Classpath libraries can be selected, reducing the potential for unintended backdoors or robustness issues introduced by unnecessary functionality. Furthermore, the source code availability supports code-level audits necessary for some certifications.
• scalability & diverse platform support
  If scalability matters to your application, our diverse platform support offers the perfect solution: we understand server-, desktop- and embedded-processors and offer a single virtual machine across the entire range.

We recognize that our customers have special needs, depending on their business models and focus:

• Semiconductor vendors nowadays frequently require a Java solution for their platform: this requires a balanced solution that will achieve good performance for a wide variety of workloads and keeps up well in competitive benchmarks. Additional customizations may be required to make specific features of an embedded processor available to the Java applications.
• Systems integrators require a balanced Java solution, that can support different workloads and applications, in most cases. However, depending on the platform, additional performance primitives may be required. Customizations can be provided to satisfy such requirements as making a cryptographic coprocessor available to Java applications.
• Embedded application developers require a virtual machine tuned to their specific application and optimizations that extract the best application performance for their specific workload. For particularily performance-hungry applications, customizations and optimizations for the virtual machine, the just-in-time-compiler and the language runtime can be provided.

We understand how these diverse requirements affect our customers and provide products and solutions with keeping them in mind.

Java virtual machine and just-in-time compiler

We offer Java virtual machine solutions, including an efficient just-in-time compiler, for a wide variety of processor architectures. Our just-in-time compiler retains a small footprint, while accelerating compute-bound workloads even for resource-constrained environments.

With our background in compiler engineering we can customize and fine-tune our virtual machine for specific processor variants or port it to different instruction set architectures.

Java runtime environments

The Java runtime environment consists of a set of APIs and libraries that provide an abstraction on top of the underlying hardware and operating system. Depending on the target application, different runtime environments are available: J2SE (standard-edition) or J2ME (micro-edition).

We can customize, optimize, or extend the runtime environment used by the virtual machine to suit the needs of specific applications. This may include application-specific optimizations, the addition and usage of performance primitives for a given processor, or the addition of new APIs to support hardware-specific features.

Engagement model

Our embedded Java products are always customized to your target platform and application requirements. As a consequence, every customer engagement goes through three phases:

1. Request-for-information (RFI) phase
   We initially gather information on your application environment and requirements to establish an understanding of the required engineering efforts and tuning. This can range from the completion of simple qualification sheets to an in-depth analysis of a customer application.
   We usually conclude this phase by providing a detailed proposal outlining the customizations, target performance, certifications, etc.
2. Integration and optimization phase
   After agreeing on the proposal, our engineers set out to integrate our virtual machine into the customer's solution environment. Once this initial step is done, stability and performance tests start to pin-point possible areas of improvement. Once the optimization of our virtual machine is complete, the solution will meet or exceed the agreed specifications.
3. Maintenance and support phase
   As a final stage of every project, we move the released Java solution into maintenance and support mode. Issues can be reported electronically and we may release bug-fixes, performance optimizations or compatibility improvements, whenever necessary.

The commercial frameworks for each Java project will differ, depending on our customers' business models and the target volume for each solution.

Contact us

If you have questions, require further details or would like to discuss the use of our Java virtual machine for your solution, don't hesitate to contact us.