Practical Integration of Java-Oriented Technologies and 2.5/3G Platforms

By: Eva Skoglund; Bryan Hartlen; Marc Erickson; Angus McIntyre

Aug. 1, 2003 12:00 AM

Broad ranges of deployment choices are available to developers as they engage in new projects that will leverage the power of wireless communication platforms. While deploying services through third-generation (3G) and second-and-a-half generation (2.5G) wireless terminals presents challenges that are quite different from those encountered in personal computers and servers, many familiar environments have been adapted to resource-constrained devices.

This article discusses the practical integration of Java-oriented technologies and 2.5G/3G platforms and what you need to know when dealing with resource constraints and the management of software components through development, testing, deployment, and maintenance.

Communication handsets already offer functions similar to those available on desktop computers, including Internet access. While handheld devices are becoming more capable and powerful with each generation of products, they continue to be resource constrained compared to their desktop brethren. Limited amounts of memory, processing, and battery power are realities for the wireless developer.

These hardware limitations must be compensated for by smart application development and tight middleware integration. Rather than just acting as browsers for reformatted Web content, 3G handsets have the potential to host application software specifically built to implement client and service aspects of a solution. Since developers are no longer restricted to "thin-client" approaches, components installed directly within wireless devices have greater access to device features, sensors, and actuators. Clearly, developers will need access to a new generation of end-to-end tools that work within an open, universal tools integration platform. These will help address the special needs of multi-language, multi-platform, and multi-vendor development environments.

The challenge is to combine flexibility and broad functionality with the demands for very limited memory, processing, and battery power. 3G handsets will be built on a component base that provides the robust and reliable platform on which applications can be hosted. 3G is where the phone world meets the computing world. Voice communication will continue to be central while multimedia, secure e-business transactions, and data services will provide differentiation. A 3G handset will need to have the same reliability as a phone, but the same functionality as a computer, and still be small and power efficient.

Let's use an example to illustrate the reality of merging voice, data, and communications onto modern-day devices (cellphones, PDAs, and handheld computers) and enabling a new dynamic e-business application model. A technician on a service call uses a handset to view a full-motion video on how to remove a part from a photocopier. Using the same handset, the technician submits an order for the part and receives verification that the part has been reserved for his customer. Using location-based services, the server application, determining that there is a delivery van with the part on board in the neighborhood, uses a cellular SMS message to divert the driver to the technician's location.

As applications are extended to mobile devices, new technologies will be required to provide productivity to the end users while shielding them from the inherent complexities of integrating local and remote services. Local services such as bar code scanning, scalable vector graphics, full-motion video, and voice navigation will be required on the device. Remote services residing within the service infrastructure, such as location-based (GPS), transactional, and messaging services, will need to be accessed wirelessly by the device.

All these technologies exist today. To successfully integrate and deploy them on a constrained handset is a "simple matter of programming." To get there faster requires two things: the right platform and the right tools.

The role of Java in these systems is hidden from the end user, but it will play an important role for the developers of the wireless terminals and infrastructure equipment.

Next Generation Communication Systems
What are the reasons for using Java in 3G/2.5G terminals and infrastructure? Java will be successful within the communication segment for the same reasons it's successful in the IT segment: (1) time-to-market through productivity, and (2) flexibility and stability through open standards.

Shifting market demographics, global competition, and significant development and maintenance costs have reinforced the need for increased flexibility and productivity. No one application or service is going to meet all needs, and as a result service providers must have the ability to quickly and efficiently deploy new applications. This drives the fundamental idea of building a general platform with predefined capabilities and shared services that can be configured in real time with applications and add-ons, resulting in differentiable end products. The J2ME specifications provide a definition of such a platform for devices of varying capabilities. Developing applications according to these J2ME specifications:

Ensures application compatibility and portability with device capabilities

Reaps the productivity benefits of the Java programming model and accessibility to a continually growing base of skilled developers

Simplifies the integration of applications and services that reside in both the handset and infrastructure sides of the wireless link

Selecting the best J2ME implementation is important, as it's the implementation of the "platform" the underlying real-time operating system (RTOS) and virtual machine that provides to a varying degree:

A safe and secure programming environment that protects the system from faulty add-ons that could corrupt the system

A layered software design with isolation mechanisms that prevent direct access to hardware and RTOS services

A fast and reliable execution environment with minimal memory consumption and efficient power usage that enables applications to take full advantage of available hardware resources in order to produce high quality service

Tested and certified, not just compatible, implementation against the J2ME specifications' "Java-powered" runtime environment

An extensible platform for connecting applications deployed on the handset with data and applications within the infrastructure

Runtime downloading (and unloading) capabilities of both Java applications and native system components

Efficient and intuitive programming tools for all of the above

In the following section, OSE Systems and IBM describe how the integration of RTOS and J2ME-certified runtimes can be optimized for the wireless handset market. Experience is taken from their recent efforts in integrating OSE Systems' RTOS OSE and IBM's WebSphere Micro Environment.

Development took place in an integrated tools platform with development tools based upon the open source Eclipse platform, an open universal tools integration environment. Development tools that are powered by Eclipse technology such asIBM's WebSphere Device Developer (an offering specifically targeted to embedded platforms) are also discussed as examples of the tooling needed for embedded Java applications.

The Right Platform Not All J2ME Implementations Are Created Equal
J2ME is a direct response to the recognition that not all devices are created equal. It provides a means for defining various device classes and a minimum level of capability and services that can be guaranteed on compliant devices. It does not, however, specify how well those services will perform. The devil is in the details of the platform's design, functionality, and implementation how the individual components of the platform, the RTOS, and the virtual machine are designed and implemented, what capabilities they have, and collectively how they are integrated.

General Performance
Footprint and Memory Costs
One of the largest costs in a 3G handset is the memory. Designing a device with loads of expensive RAM and high-performance flash is not an option for many manufacturers. The right platform will be based on software specifically designed from the ground up to be small, scalable, and configurable, not carved down from an enterprise implementation.

The RTOS plays an important role in saving memory, not only by providing a scalable, small footprint solution, but also by implementing memory-conserving features such as:

Limiting the amount of RAM consumed during execution

Preventing memory fragmentation

Supporting persistent memory types and enabling flash memory to function as the work memory, including "instant-on" execute-in-place (XIP) features that allow platforms to execute code directly from the flash memory without prior loading into a RAM buffer

Supporting dynamic remapping of applications' memory pages between RAM and flash

Building on a strong RTOS, J2ME platforms at the simplest level assist in reducing the memory footprint for small devices by specifying the set of services available to an application on a compliant platform. This allows these services to be implemented once and then be shared by each application. In the wireless domain this also means improved performance as only the application, not the core services, need to be deployed over the wireless connection.

At a deeper level, developers also need to look at the overall memory of an application as it runs on the device. Some virtual machines grab small amounts of memory up front (to reduce the initial footprint), and incrementally grab memory as it's needed (costing in terms of speed). Others grab more memory up front, but less over time (up front memory hit, but faster over time). The ideal solution is a virtual machine that is customizable and tunable. With J9, the virtual machine inside WebSphere Micro Environment, initial and incremental memory heap space can be set to meet the specific service needs and device capabilities.

Finally, once the application has been designed and optimized, there are benefits to be realized in how it is deployed to the device. Depending on the type of application and the characteristics of the device, it may be more beneficial to execute the application out of flash rather than RAM. This could be to minimize RAM requirements or to provide the application with an "instant-on" capability.

Execution
The execution speed of applications on these consumer handsets will continue to be an important success factor. Java applications have previously suffered a bad reputation because of their interpretive nature. While it's true that interpreters will generally run slower than compiled applications, the difference at the application level is not necessarily noticeable; in situations where it is noticeable, there are optimized runtime options such as ahead-of-time (AOT) and just-in-time (JIT) compilation.

Just-in-time (JIT) compilation is a runtime option that uses a compiler within the virtual machine to translate Java bytecodes into native machine language for a specific device. A cache of memory contains compiled machine language prepared "just in time" for use. Execution of recurring bytecodes is then handled directly from the machine language in cache. After the initial "compilations," JIT technology improves performance at the cost of increased memory and start-up time.

Ahead-of-time (AOT) compilation is an option that converts Java bytecodes into native machine language for the specific device at deployment time. Unlike JIT, compilation occurs on the development host. The result can be packaged "ahead of time" into a compact executable for direct loading and execution within the virtual machine environment. AOT compilation can be extremely effective when applied selectively to application hotspots. It can provide near JIT performance without the start-up time penalty and at a fraction of the memory costs.

The J9 virtual machine was designed first and foremost to interpret bytecodes quickly. Building on this strong foundation, the JIT and AOT compilers provide the application developer with options for managing the speed versus memory cost trade-off. The significance of this flexibility is considerable given that the J9 virtual machine can execute applications deployed as bytecodes, AOT or JIT compiled machine code, and, most important, any combination of the three.

Application Security and Continuity
While ensuring reliability of standalone software applications, it's equally important to design a device with system robustness in mind. Downloaded applications and services cannot be allowed to corrupt the system. Separation of system-critical and noncritical software is essential and the operating system in the device should provide isolation mechanisms and memory protection for this purpose. For example, in the case of OSE's dynamic loading/unloading capabilities of native software (C/C++), special protection mechanisms have been introduced to ensure that loaded modules will be memory protected when taking advantage of a hardware MMU.

Introducing a Java runtime environment that takes advantage of the RTOS' inherent security in a 3G handset has the great benefit of providing a secure and protected environment for application software, which is often written in Java. The handset's native environment (C/C++) that controls the device will be protected from the Java application environment. In system architectures that would benefit from greater separation, multiple virtual machines could exist on the handset and can be started and stopped independent of each other. In addition, when the RTOS supports native runtime downloads, even new, updated Java Virtual Machines can be dynamically installed after a handset is produced and deployed.

Deterministic Real-Time Behavior
Deterministic real-time behavior is a requirement in today's 2G mobile phones. To wirelessly deliver your voice to any location in the world within fractions of a second, 2G platforms include software that must control radio components, digital coding and decoding of voice, the relationship with base stations, and setup facilities that connect and disconnect calls. Moving to 3G handsets will not change the requirement for deterministic real-time behavior. Users will not accept calls suddenly being disconnected or the other party's voice sounding slow and distorted.

The challenge will be to keep today's excellent performance and reliability, while introducing the new services that high-speed, packet-based data transmission enables. For multiple Java applications to coexist in a resource-limited device, the Java runtime environment needs deterministic real-time behavior.

The design of the virtual machines has also moved forward to allow for deterministic execution. One specific area is in the garbage collection of the virtual machine. To illustrate, the IBM J9 virtual machine inside WebSphere Micro Environment has the following features to assist in the development of deterministic applications.

Real-time systems need to recover memory efficiently. Look for features such as precise garbage collection (GC) as opposed to conservative garbage collection. GC should also be incremental, so the virtual machine is not locked during GC.

In the most serious of deterministic cases, GC should also allow interrupts. This stops GC immediately so critical events can be processed at the highest possible priority. An example of this would be receiving an incoming phone call while gaming.

Having a virtual machine implement deterministic functions has limited value if the underlying RTOS does not predictably implement real-time elements. Operating systems such as OSE are an example of a true embedded real-time system, designed from the ground up for demanding needs like determinisms, reliability, and robustness. Besides the classical features such as preemptive scheduling, lightweight processes, small footprint (measured in tens of kilobytes), scalability, efficient interrupt handling with short interrupt latency, and an interrupt-centered device driver model, there are other features to look for in an RTOS:

Message-based architecture to ensure ease-of-use, high performance, advanced debug capabilities, transparent IPC in distributed systems, and memory-protected systems

Memory management with a focus on performance even when using low-performance memory types, efficient prevention of memory fragmentation, and multiple memory pools to allow robust system design

Automatic error handling with a multilayered error handler approach

Process supervision and automatic resource cleaning, which enables a system to be self-recoverable

The Right Tools The Java Developer Is Efficient
As the 3G handset becomes a deployment platform within an overall pervasive computing context, tools to manage the end-to-end project life cycle will be needed. It will be customary to establish new development relationships as part of these projects. Often several companies or departments will need to collaborate on solutions that deploy across deeply embedded controllers, handsets, personal computers, servers, and even mainframe systems that handle millions of devices concurrently. The development life cycle starts with managed requirements, then progresses to modeling, code development, debugging, installation and management tasks, and testing. Testing takes on new aspects as multiple handset platforms, deployment networks, Web services servers, and service providers must be accommodated. Tools that manage all of these aspects of project development and deployment must integrate together well if developers are to progress efficiently.

As in the device runtime discussion, it will be important for the Java and native (C/C++ and assembler) tooling environments to be well integrated. Being able to switch between task-aware freeze-mode and run-mode debugging is important in real-time systems as certain bugs cannot be found unless parts of the system can execute while others are frozen.

Traditional source code debugging needs its complement in system-level debugging where events can be traced and analyzed, and design flaws can be found. Advanced system-level debugging is possible when the system design is based on a message-passing architecture with automatic resource cleaning, like OSE enables. Profiling of the CPU and memory usage as well as postmortem debugging are other needed debugging tools. The OSE Illuminator debug tool suite is implemented in Java, which provides for easy integration with a Java development environment like Eclipse-based WebSphere Studio Device Developer.

While Java's portability and productivity benefits are well known, tooling designed for the embedded developer will need to provide several features above and beyond those found in a simple IDE. Real productivity is achieved with the following:

The ability to develop and debug in both on-host emulation environments and the actual on-device environment

The ability to develop and debug mixed mode, Java, and C/C++ applications

Execution analysis tools that operate on the device and highlight application bottlenecks by profiling memory, stack and thread usage, and priorities

Setup and configuration wizards that ensure applications are developed against the desired J2ME configuration or profile and for the desired target hardware

Wizards for recommending which portions of the application should be compiled as Java bytecodes, AOT, or JIT executables

Wizards that package an application for execution out of flash memory (XIP)

Wizards for packaging applications for deployment within an OSGi or enterprise side service

Ability to seamlessly create new custom tool features or to integrate new or better tool capabilities from third-party providers

There are a large number of competing and complementary operating platforms and middleware technology offerings available. New project and business relationships may mean that a developer needs to bridge between multiple tools and collaboration environments. Since projects will often need to address additional deployment environments, including creating and managing metadata for complex middleware, multiple compatible development offerings may need to be considered. When an open, extendable integration framework like Eclipse is the basis for tools, it becomes easier to accommodate multiple-platform, multiple-language, and multiple-vendor development tasks.

Part of the challenge for developers working to deploy solutions across server and wireless handset platforms involves collaboration and team coordination. A universal tools integration platform like Eclipse is equally at home in supporting a variety of development languages (Java, AspecJ, C/C++, Cobol, and Smalltalk, for example) and a broad range of enterprise and embedded deployment platforms. Eclipse supports all these environments through common access to modeling tools, testing environments, and concurrent access to multiple source code repositories. Several vendors are now offering solutions that integrate their areas of specialization with the Eclipse platform.

Offerings like QNX Momentix and TimeSys TimeStorm use the same Eclipse platform and provide speciality tools for working with QNX Neutrino and TimeSys Linux in C and C++ language environments. Source code control and management offerings from Computer Associates (All Fusion), MERANT (PVCS), Rational (XDE), Borland (Together Control Center), MKS (Source Integrity), Serena (Workbench), LogicLibrary (Logidex Asset Expert), Eclipse (CVS), Starbase (StarTeam), Telelogic, and Instantiations (CodePro Studio) let you plug in access to a variety of VCM and source code management systems. Offerings like IBM's WebSphere Studio Application Developer extend Eclipse to include visual editors, development of enterprise services, middleware access, and more. Organizations like Quest Software, Parasoft, JUnit.org, and Scapa Technologies have provided test extensions.

Summary
3G handsets will need to combine phone reliability and real-time requirements on small and resource-constrained devices with ever-changing application functionality. J2ME specifications provide definitions of general platforms for devices of varying capabilities and will serve as the basic software building blocks for these devices. Successful implementations of the J2ME platform will require an RTOS and Java runtime environment that focus on deterministic real-time behavior and low memory usage. Successful projects will need to efficiently integrate and work with tools from multiple vendors for multiple development and deployment platforms and in multiple languages. The combination of J2ME technology and Eclipse-based tools is the key to powerful solutions.

About Eva Skoglund
Eva Skoglund holds a Master of Science degree in Computer Science from the Royal Institute of Technology in Stockholm. Currently, Skoglund is product marketing manager for wireless systems for OSE Systems, a real-time operating systems company

About Bryan Hartlen
Bryan Hartlen works in business development, product marketing, and IP licensing areas and manages IBM's family of embedded Java products. Previously, he developed or managed software developers on platforms that ranged from mainframe applications to shop floor control systems to PCMCIA cards.

About Marc Erickson
Marc Erickson has been a key participant in several international innovations from IBM including workflow technology and service support center development. He is now on assignment as the communications manager for Eclipse.

About Angus McIntyre
Angus McIntyre is the director of business development for embedded technology at IBM and has spent his entire career on application development tools (OTI, IBM Canada Lab, VisualAge for Java, VisualAge Micro Edition). He holds a BS in computer science and statistics and an MBA.