Project overview Pervasive computing is now a reality with the massive deployment of mobile appliances, particularly smart phones. Well-established pervasive applications include home automation, healthcare monitoring, and the intelligent city. These applications are starting to significantly impact society and the economy by bringing electronic commerce to everyday objects, by decreasing homepower consumption and by improving human safety. Despite the increasing importance of pervasive applications, providing adequate support for them within a computing environment remains a challenge. Pervasive applications vary greatly in their resource requirements (processors, memory,bandwidth, and disks): for critical applications, such as surveillance systems, a known bounded amount of resources must be guaranteed for the application to run properly; for multimedia applications, the amount of resources needed may change over time and dynamic adaption is often required. To manage these differing and possibly varying resource requirements, a system of resource reservations is required. Because the availability of resources is global to a computing environment, such reservations have to be managed at the middleware level. Modern pervasive middleware is typically implemented using Java, for example with OSGi or Android, because of its safety, flexibility, and mature development environment. In fact, Java is the most used programming language today. However, the Java virtual machine specification has not been revised since 1999, at the time when the idea of pervasive computing was first introduced. It was designed to execute only a single application at a time, and thus it does not provide resource accounting or per-application resource reservations.Current pervasive middlewares are thus unable to reserve resources for critical applications, which may cause these applications to crash or hang when insufficient resources are available, and are unable to provide resource accounting, making it impossible to balance the load on the devices and to optimize resource use. The Infra-JVM project will investigate how to enhance the design of Java virtual machines with new functionalities to better manage resources. We have identified three key functionalities for which the Java virtual machine does not provide an adequate interface or for which the current implementation is a bottleneck: Resource reservation: the Java virtual machine was not targeted to support more than one application. It does not provide a per-application resource accounting and reservation for memory, bandwidth, disk, etc. We propose to define the notion of resource container inside the Java virtual machine able to account and reserve resources on a per-application basis. Scheduling policies: the Java virtual machine provides a time-sharing scheduler that is unable to accept CPU reservations and is unable to anticipate dependencies between applications. We propose to define a new language to allow the pervasive middleware to define its own scheduling policy, in terms of the applications that it executes. Resource optimization at the middleware level: Optimally placing applications on devices requires resolving a number of conflicting constraints. Constraint solving requires searching through a state space, which is typically implemented using a backtracking algorithm that induces frequent saving and restoring of memory states. However, intensive memory copy is known to be a bottleneck on modern architectures that have complex cache hierarchies. Furthermore, copying objects in Java can only be implemented at the field level, which prevents the use of well known low-level optimizations. We proposeto extend the Java virtual machine with an efficient memory snapshot mechanism that relies on page-level protection mechanisms provided by modern hardware and OSes. Our visionis that the Infra-JVM willimplement resource management mechanismsin a way that existing pervasive middlewares and applications can use them with little or no modification.We will provide a notion of resource container to account and reserve resource, independently of the pervasive middleware. At deployment time, the pervasive middleware will configure the resource containers by loadinga XML file describing the requirements in term of criticality, scheduling policy, amount of memory, amount of bandwidth and amount of disk. Before loading a critical application, the pervasive middleware will verify that requested resources are available. For other applications, the middleware will just provide a best-effort policy. Then it willuse thecontainer to manage resource accounting and reservations for an application in theJava virtual machine, and will use the constraint solver to optimally balance the load between the devices and to guarantee enough resources for critical applications. To prototype these functionalities, the Infra-JVM project will rely on the previous work of the Regal team on VMKit. VMKit provides the core of a managed runtime environment (MRE), allowing new managed environments to be rapidly developed. VMKit has been successfully used to develop a .Net virtual machine and a Java virtual machine, both having performance comparable to that of the well-established open source MREs Cacao, Apache Harmony and Mono. The experience that we acquired during the development of VMKit is key enabler for the success of this project. As a result of the project, we will propose a new Java virtual machine prototype based on VMKit that will integrate functionalities for resource accounting and reservation, for application-driven scheduling,and for memory snapshots. We will evaluate this prototype on a pervasive end-to-end experimental use-case provided by the Triskell team. This use-case is an information system that allows real time communication and coordination between firefighters and various command positions.It executes on OSGi, a Java component-oriented framework that targets pervasive computing. This use-case contains critical applications that require resource reservations and global load balancing. Under the current Java virtual machine, the critical application aborts because it lacks resources, and the overall performance is poor because OSGi’s components are inefficiently placed and scheduled. To ensure the availability of adequate resources, the use case will rely on the advanced resource reservation functionality. To provide resource optimization at the middleware level, we will use the Choco constraint solver provided by the Constraint team. Choco is written in Java and its performance will be improved using the memory snapshot mechanism that we will develop. The success criteria are: an improvement of application performance thanks to the load balancing mechanism, and a guarantee that critical applications always have enough resources to execute. The Infra-JVM must also not degrade applications that do not use the new functionalities, making it possible to propose to integrate the approach into industrial Java virtual machines.