Late Specialization of Embedded Java Systems for Small and Restrained Devices

Abstract

Java is an attractive technology for embedded and constraint devices, thanks to its safety, portability, and low bytecode footprint properties. However, the important size of a Java environment obliged embedded devices producers to use degraded and features-limited specifications of Java, like J2ME and Java Card. These early specializations of Java lose applicative-level compatibility with the standard edition, and only address particular use cases.

Our work consists in allowing using standard Java on constraint embedded systems, through a late and aggressive specialization that occurs after the deployment of applications on the system. The late occurrence of specialization allows to infer the usage conditions of the system more accurately, and to tailor it "on demand" according to the applications that run on it.

Indeed, contrary to systems which rely on a custom-made specification (like J2ME or Java Card), or a system customization prior to its deployment (library extraction), we rely on a late specialization scheme that occurs after the deployment of the system within a virtual execution environment. Late specialization offers several advantages for the embedded system designer:

• Applications can be written using a standard implementation of Java, and not some derivative that is source-incompatible with the original implementation (like J2ME or Java Card). The system as a whole (system + deployed applications) being customized as a sole entity.
• The deployed state of the system gives much more static information to the customization tools.

The customization tools can thus work in a much more friendly environment, with plenty of static data and information about its future behavior. As a side effect, customizing a deployed system has many other benefits in the context of embedded devices:

• The system deployed off-board can be frozen, customized and transferred to its real execution environment at any time of its execution. This process is totally transparent for the system.
• The system can be executed off-board up to the state desired to be the system initial state on the device. This allows to perform all initialization tasks off-board, and have the system immediately active once deployed on the target device.
• As a consequence, initialization data and code can be discarded from the final system, reducing its footprint. Moreover, more data can be inferred as read-only, and thus placed in ROM.

The result is a very low-footprint, custom-made system ready to run a set of deployed applications. We implemented this architecture on the JITS (Java In The Small) platform.

Further reading

• My thesis document (French)
• My thesis slides (English - presented at Smart University 06)