Ongoing work at INRIA Rennes concerns embedded system software and addresses the problems presented in providing an easy and safe framework for estimating software's resource consumption, a difficult task when done manually using a benchmarking approach. Furthermore, by enabling dynamic download of Java applications, a discontinuity in the embedded application development lifecycle is introduced. This is a new and significant contribution towards opening up the use of embedded systems. Traditionally, embedded software development must consider constraints derived from the software itself or the embedded architecture. Embedded software packages for avionics or robotics contain inherent real-time constraints that require support from a background operating system. For embedded architectures, resource constraints and customer-defined resource issues (such as shared-memory multiprocessors with multiple clocks, small capacity issues with only a few memory models, and limited battery capacity) make building an embedded operating system more complex. To make embedded system development easier, we need to address two different challenges not present in current embedded systems. Our first focus is on assessing the resource consumption of embedded software (CPU, power, or memory). Our second challenge is implementing Java applications on small embedded devices such as mobile phones and personal digital assistants (PDAs). This will support dynamic application downloads and will significantly change the embedded application development lifecycle. Predicting the resource consumption of embedded software: Static worst-case execution time analysis. To verify whether a system can meet its real-time and resource constraints, predicting the resource requirements of the embedded software is paramount. In hard real-time embedded system architectures, it is especially important to predict the worst-case execution time (WCET, hereinafter omitted) of the task to demonstrate that the task can be completed within the time limit. Our ongoing research involves automatically obtaining the upper bound of application execution time on specific hardware. Static analysis of application source code is used to verify static worst-case execution scenarios; static analysis methods have become the preferred approach for execution inspection because these methods require probing all possible inputs to a given software to identify its longest execution path. Processor hardware models are used to obtain the WCET control sequence. The application of hardware models (rather than actual hardware) allows static WCET analysis to be used early in the application development lifecycle. Furthermore, for deadline verification, static WCET analysis can help select or compute hardware for real-time embedded systems and can be used to compare execution strategies across different applications. One of our achievements in static WCET analysis is the open-source analyzer Heptane (see Figure 1), which aims to obtain WCET on processors with sequential execution, cached memory, and piped execution. Heptane's modularity allows it to be integrated with different target processors and programming languages. [ALIGN=CENTER] Figure 1: Heptane Static WCET Analysis Tool[/ALIGN] We believe that an early assessment of the resource consumption of embedded software allows the fit of embedded system constraints (limited time, memory, and energy) to be validated throughout the application development lifecycle. Our ongoing work on static timing assessments will extend to other insufficient resources in embedded systems, such as energy consumption. This is a challenging new problem for hard real-time embedded systems. Introducing Java into small embedded devices offers several important advantages for extending the applications of Wireless Personal Digital Assistants (WPDAs). First, Java is portable and therefore hardware platform independent. In the widely penetrated embedded market, this is crucial for reducing application development costs. Because Java can run anywhere, application development can be done on a desktop computer without requiring support from the target hardware platform. This represents a strong break in the application development lifecycle of embedded systems. Second, Java supports dynamic application downloads and can well support WPDA application extensions (see Figure 2). [ALIGN=CENTER] Figure 2: Introducing Java into small embedded devices[/ALIGN] For these reasons, Java offers many benefits to these embedded environments. However, even though Java demonstrates many potential advantages, one of its major drawbacks is its demanding requirements for the resources needed to run programs. These resources include memory capacity, execution time, and power consumption, which are typical resources considered in the trade-offs of embedded systems. Therefore, it is clear that Java's success is conditional on the availability of a Java execution environment that can effectively utilize resources. Our research over the past four years, conducted in collaboration with Texas Instruments, aimed to provide a Java execution environment for the WPDA architecture that allows for a trade-off between execution time, power consumption, and memory consumption. In our research, we first determined the Java opcodes that have a significant impact on power consumption. Then, we designed a new method to build a modular decomposition-based Java execution environment. By applying modularity, we can specialize parts of the Java Virtual Machine (JVM, hereinafter) for a specific processor (e.g., to develop low-power features for digital signal processing (DSP) units to minimize power consumption). Finally, we ran our JVM from scratch and put it into operation on an Omap Texas-based system. Our current work focuses on the WPDA architecture of the Instruments platform (a shared-memory heterogeneous multiprocessor). We investigate how to provide a high-performance Java embedded platform with robust hardware and software collaboration. Embedded systems are currently isolated from the outside world, and their development is fraught with difficulties. Many systems use assembly or C languages. Our research on Java, particularly its performance, suggests that Java will be a valuable tool for designers building embedded systems. For users, this makes embedded systems more transparent. These characteristics also make configuring and designing widely applicable applications easier. For designers, Java provides a powerful, typing-based target language, rather than a basic language like C or assembly.