A Low-Footprint Class Loading Mechanism for Embedded Java Virtual Machines

This paper shows that it is possible to dramatically reduce the memory consumption of classes loaded in an embedded Java virtual machine without reducing its functionalities. We describe how to pack the constant pool by deleting entries which are only used during the class loading process. We present some benchmarks which demonstrate the efficiency of this mechanism. We finally suggest some additional optimizations which can be applied if some restrictions to the functionalities of the virtual machine can be tolerated

Romization: Early Deployment and Customization of Java Systems for Restrained Devices

Memory is the scarcest ressource of embedded and restrained devices. This paper studies the memory footprint benefit of pre-deploying embedded Java systems up to their activation. We find out that the more the system is deployed off-board, the more it can be efficiently and automatically customized in order to reduce its final size. This claim is validated experimentally through the production of memory images that are between 10% and 45% the size of their J2ME CLDC counterparts, while using the J2SE API and being ready-to-run without any further on-board initialization. Embedded solutions like J2ME degrade the Java environment and API right fromtheir specification, limiting their usage perspectives. By contrast, our romization scheme generates and specializes a custom-tailored Java system and API for embedded applications being deployed in a full-fledged J2SE environment

A Low-Footprint Java-to-Native Compilation Scheme Using Formal Methods

Ahead-of-Time and Just-in-Time compilation are common ways to improve runtime performances of restrained systems like Java Card by turning critical Java methods into native code. However, native code is much bigger than Java bytecode, which severely limits or even forbids these practices for devices with memory constraints. In this paper, we describe and evaluate a method for reducing natively-compiled code by suppressing runtime exception check sites, which are emitted when compiling bytecodes that may potentially throw runtime exceptions. This is made possible by completing the Java program with JML annotations, and using a theorem prover in order to formally prove that the compiled methods never throw runtime exceptions. Runtime exception check sites can then safely be removed from the generated native code, as it is proved they will never be entered. We have experimented our approach on several card-range and embedded Java applications, and were able to remove almost all the exception check sites. Results show memory footprints for native code that are up to 70% smaller than the non-optimized version, and sometimes as low than 115% the size of the Java bytecode when compiled for ARM thumb

Ahead of time deployment in ROM of a Java-OS

This article shows how it is possible to place a great part of a Java system in read-only memory in order to fit with the requirements of tiny devices. Java systems for such devices are commonly deployed off-board, then embedded on the target device in a ready-to-run form. Our approach is reach an advanced state of deployment off-board, which allows us to maximize the amount of data placed in read-only memory. Doing so, we are also able to reduce the overall size of the system

Extensions Temps-Réel pour Exo-Noyau Embarqué

Les cartes à puces sont des petits objets portables axés principalement sur la sécurité ($10^9$ unités vendues principalement en Asie et en Europe). Afin de permettre aux logiciels encartés de supporter plus de services, les systèmes d'exploitation pour cartes ont évolué d'une plateforme d'exécution monolithique dédiée vers des architectures systèmes plus ouvertes qui supportent le chargement dynamique de code. Cet article présente les problèmes temps-réel du système d'exploitation pour carte Camille, qui présente les caractéristiques suivantes : chargement dynamique de code, vérification de type embarquée, compilation à la volée, et chargement dynamique de composants systèmes. D'une manière plus générale, il traite des difficultés à accorder les extensions temps-réel avec les principes des exo-noyaux

A Low-Footprint Class Loading Mechanism for Embedded Java Virtual Machines

This paper shows that it is possible to dramatically reduce the memory consumption of classes loaded in an embedded Java virtual machine without reducing its functionalities. We describe how to pack the constant pool by deleting entries which are only used during the class loading process. We present some benchmarks which demonstrate the efficiency of this mechanism. We finally suggest some additional optimizations which can be applied if some restrictions to the functionalities of the virtual machine can be tolerated

Romization: Early Deployment and Customization of Java Systems for Restrained Devices

Memory is the scarcest ressource of embedded and restrained devices. This paper studies the memory footprint benefit of pre-deploying embedded Java systems up to their activation. We find out that the more the system is deployed off-board, the more it can be efficiently and automatically customized in order to reduce its final size. This claim is validated experimentally through the production of memory images that are between 10% and 45% the size of their J2ME CLDC counterparts, while using the J2SE API and being ready-to-run without any further on-board initialization. Embedded solutions like J2ME degrade the Java environment and API right fromtheir specification, limiting their usage perspectives. By contrast, our romization scheme generates and specializes a custom-tailored Java system and API for embedded applications being deployed in a full-fledged J2SE environment

A Low-Footprint Java-to-Native Compilation Scheme Using Formal Methods

Ahead-of-Time and Just-in-Time compilation are common ways to improve runtime performances of restrained systems like Java Card by turning critical Java methods into native code. However, native code is much bigger than Java bytecode, which severely limits or even forbids these practices for devices with memory constraints. In this paper, we describe and evaluate a method for reducing natively-compiled code by suppressing runtime exception check sites, which are emitted when compiling bytecodes that may potentially throw runtime exceptions. This is made possible by completing the Java program with JML annotations, and using a theorem prover in order to formally prove that the compiled methods never throw runtime exceptions. Runtime exception check sites can then safely be removed from the generated native code, as it is proved they will never be entered. We have experimented our approach on several card-range and embedded Java applications, and were able to remove almost all the exception check sites. Results show memory footprints for native code that are up to 70% smaller than the non-optimized version, and sometimes as low than 115% the size of the Java bytecode when compiled for ARM thumb

An Operating System Architecture for Future Information Appliances

Abstract. A software platform for developing future information appliances requires to satisfy various diverse requirements. The operating system architecture presented in this paper enhances the flexibility and dependability through virtualization techniques. The architecture allows a system to use multiple operating systems simultaneously, and to use multi-core processors in a flexible way. Also, dependability mechanisms in our architecture will avoid crashing or hanging a system as much as possible in order to improve the user experience when defects in the software are exposed. We present a brief overview of each component in the operating system architecture and some sample scenarios that illustrate the effectiveness of the architecture

Spécialisation tardive de systèmes Java embarqués pour petits objets portables et sécurisés

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 articular use cases. Our work consists in allowing using standard Java on constraint embedded systems, through a late and agressive 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. Our contributions are as follows: first, we define the romization notion, which consists in deploying a system off-line before capturing and transfering its memory image to its target device. From this definition, we propose a romization architecture that permits to capture a memory image of a system at any time of its execution. Then, we address analysis and specialization techniques allowing to produce an embeddable version of this memory image. Our evaluation shows that late specialization makes it possible to obtain an embeddable version out of a deployed standard Java environment.Java est une technologie attractive pour les équipements embarqués et contraints, de par ses propriétés de sûreté, de portabilité et de faible empreinte mémoire du code. Cependant, la taille imposante d'un environnement Java complet a obligé les producteurs d'équipements embarqués à utiliser des spécifications dégradées de Java aux fonctionnalités limitées, telles que J2ME ou Java Card. Ces spécialisations précoces de Java perdent la compatibilité au niveau applicatif avec l'édition standard, et ne peuvent ainsi s'adresser qu'à des cas d'utilisation particuliers.Notre travail consiste à permettre l'utilisation de l'édition standard de Java sur les systèmes contraints, au travers d'une spécialisation tardive et agressive du système qui intervient après déploiement de ses applications. L'occurrence tardive de la spécialisation permet de mieux déterminer les conditions d'utilisation du système, et donc de le spécialiser « sur mesure » par rapport aux applications qu'il exécute.Nos contributions sont les suivantes : dans un premier temps, nous définissons la notion de « romization », consistant à déployer un système hors-ligne avant de capturer et de transférer son image mémoire vers l'équipement sur lequel il doit s'exécuter. De cette définition, nous proposons une architecture de romization capable de capturer une image mémoire du système à n'importe quel moment de son exécution. Dans un second temps, nous traitons des moyens d'analyse et de spécialisation permettant de rendre cette image mémoire embarquable. L'évaluation effectuée montre que cette spécialisation tardive, appliquée à un environnement Java standard déployé, permet effectivement d'en obtenir une version minimaliste et embarquable sur un équipement contraint