Main features of Aphelion JREs

Aphelion JREs offer the following main features not offered in their entirety by JREs from other providers, including Sun and IBM:

• Facilitate reliable deployments of Java applications, with exceptional runtime performance, on many types of devices based on popular processors running Linux or other commonly used operating systems (OSs).


• Available in two main configurations, each of which can be customized for the specific needs of Apogee's customers:
  • Micro Edition JREs (ME JREs) compatible with Sun's J2ME platform.
  • Standard Edition JREs (SE JREs) compatible with Sun's Java 5 (J2SE 1.5) platform or with customer-requested subsets of Java 5 platform. Note that SE JREs compatible with Sun's Java 6 (J2SE 1.6) platform will be available in near future.
  
  
• Every ME or SE JRE is comprised of OS/processor ports of the same J9VM and JIT compiler. This means that Apogee can provide outstanding technical support for ME and SE JREs at a very reasonable cost.


• Each ME JRE is comprised, in addition to the ports of J9VM and JIT compiler, of the OS/processor ports of the following components:
  • IBM's Foundation Class Library (FCL) compatible with Sun's latest J2ME CDC Foundation Profile.
  • Customer-requested optional components from IBM, Apogee, or providers of open-source Java software, each of which is compatible with Sun's J2ME CDC or CLDC platform.
  The compatibility with Sun's J2ME platform means that every ME JRE can be certified as compliant with Sun's J2ME platform, which, in turn, means that the devices having the JRE installed on them can have the 'steaming coffee cup' logo and/or 'Java Powered' slogan.


• Each SE JRE is comprised, in addition to the ports of J9VM and JIT compiler, of the OS/processor ports of the following components:
  • The Java 5 compatible Harmony class library from Apache.org, or a subset of API packages from Harmony needed by customer's Java applications, or by requested optional components (see below), or because of the manner in which the SE JRE will be used.
  • Customer-requested optional components from IBM, Apogee, or providers of open-source Java software, each of which can use any Java 5 compatible API packages from the Harmony class library.
  • A 'glue' layer of special Apogee-created Java classes that make the Java 5 compatible APIs from Harmony work with the port of J2ME compatible J9VM.
  
  
• Each SE JRE accepts and runs the JAR files of Java applications in Java 5 format, and can include the support for and implementations of various Java 5 features provided in one of the following sets:
  • The Basic set includes: (i) fully supported Enhanced 'for Loop', Autoboxing/Unboxing, Static Import, and Varargs; and (ii) partially supported Typesafe Enums, Generics, Reflections, Assertions, and Annotations/Metadata. Note that a partial support for a given feature does not include the underlying support that would be provided by a port of J9VM for the full support. For example, the partial support of assertions means that each assertion is accepted but is not acted upon by a port of J9VM.
  • The Full set includes: (i) all that is included in the Basic set; (ii) the ports of java.lang, java.util, java.rmi, java.jdbc, and other relevant API packages from Harmony; and (iii) fully supported JAXB (Java Architecture for XML Binding adopted from Sun's open-source Glassfish project) and Reflections (needed by JAXB APIs).
  • The Expert set includes: (i) all that is included in the Full set; (ii) fully supported Assertions, and Annotations/Metadata; and (iv) fully supported remaining Java 5 features requested by a customer, such as Typesafe Enums, Generics, Assertions, Extended Math, Annotations/Metadata, Process builder, Formatter, High precision timing, etc.
  
  
• Apogee can create the ME and SE JREs for devices based on many OS/processor platforms.
  Specifically, the "OS" can be any of the following:
  • Commercially offered 'embedded' Linuxes (Wind River's Commercial Grade Linux, MontaVista Linux, BlueCat Linux, TimeSys Linux, etc.), Linuxes from open-source providers (Debian Linux, Deng Linux, OpenWRT, etc.), and 'in house' implementations of recent Linux kernels (2.4.x and higher).
  • Enterprise Linuxes (RedHat Linux, RedHat MRG Linux, SUSE Linux, etc.).
  • Windows Mobile 5.x and 6.x; Windows CE 4.x, 5.x, and 6.x.
  VxWorks 5.x and 6.x.
  • LynxOS 4.x and 5.x; QNX Neutrino 6.x; Integrity 4.x and 5.x.
  • Popular UNIX OSs (BSD UNIX, for example.
  
  
  The "processor" can be any of the following depending on the OS running on the processor:
  • x86, PowerPC, ARM, XScale, MIPS, or SH4 processors running any Linux.
  • x86, ARM, or XScale processors running Windows Mobile or Windows CE.
  • x86, PowerPC, ARM, XScale, or MIPS processors running VxWorks.
  • x86, PowerPC, or MIPS processors running LynxOS, Neutrino, Integrity, or BSD UNIX.
  
  
• The ME and SE JREs are highly suitable for deployment of Java applications on many types of devices based on embedded systems. Specifically, after Apogee licensed IBM's Java technologies in 2003, it created at least one JRE for each of the following types of devices (over 50 JREs in total, more then other licensees of IBM's java technologies combined):
  • Wireless communication devices (cell phones and other 'hand-helds', telemetric devices, navigational and global positioning systems, etc.).
  • Electronic consumer appliances (smart phones, PDAs, set-top boxes, residential gateways, etc.).
  • Internet devices (residential hubs, routers, distributed servers, etc.).
  • RFID readers, 'edge' servers, and premises servers.
  • Industrial devices (sensors, monitors, controllers, gateways, robots, etc.).
  • Devices used in distributed enterprise management systems.
  • Point-of-sale terminals including those with color touch-screens, and premises controllers of such terminals.
  • Telematics and infotainment devices.
  • In near future, safety and mission critical devices (Apogee is a member of JSR-302 expert group defining the Safety Critical Java Technology).
  
  
• ME and SE JREs are also highly suitable for deployment of all kinds of Java applications including the following:
  • Large and/or complex applications for sophisticated devices, such as set-top boxes, residential gateways, Internet routers, Telematics and Infotainment devices, etc.
  • Applications compatible with the Java 5 platform.
  • Applications that use the Java 5 features.
  • Applications the components of which are available in form of dynamically loaded OSGi R3 or R4 bundles.
  • Applications that use client-side runtimes and/or application-level packages from Apogee's extensive offering of such runtimes and packages.
  • Applications that use all kinds of graphics, including the J2SE Java2d and Java3d graphics and the graphics created with Sun's Swing widget toolkit.
  • Applications that use extensively the C/C++ native methods.
  • Applications that need fast access to the Internet.
  • Applications that come in form of CORBA objects.
  • Real-time Java applications and, in near future, safety-critical Java applications.
  
  

In addition to the above main features, the SE and ME JREs come with other valuable features and enhancements, which have made Apogee's JREs the best choice among JREs from other providers for deployment on advanced devices and for running large and/or complex Java applications targeted at such devices.

• Each ME or SE JRE can be provided in a 'development' configuration that is highly suitable for creating, testing, debugging, and performance tuning Java applications. Specifically, each development JRE effectively supports and facilitates:
  • Remote (from a Windows/x86 or Linux/x86 development platform) debugging and profiling of Java applications during runtime execution of their JAR files on the development JRE.
  • Tracing of Java heap allocations, garbage collections, and executions of Java threads.
  • Dynamic dumping of Java heap or selected portions of Java heap.
  The obtained tracing and dumping information can be used to minimize the heap allocations and garbage collections, and to reduce the multi-threading overhead.


• Each SE JRE can be provided in a 'generic' configuration suitable for deployment on several types of devices that require distinct subsets of Java 5 or 6 API packages. Specifically, each generic SE JRE includes a port of the entire Harmony class library or the largest subset of possibly needed Java API packages from Harmony, and comes with special tool for creating its 'instantiations', each of which only has the port of a subset of Harmony APIs that are actually needed by Java applications targeted at a given type of devices.


• Each ME or SE JRE can be provided in a configuration compliant with the Real-Time Specification for Java (RTSJ) and, in near future, with the Safety Critical Java Technology (SCJT) being defined by JSR-302, in which case:
  • It also includes the OS/processor port of Apogee's RTSJ Class Library (RTSJCL) with the performance tuned implementations of RTSJ features that do not have to be implemented in a Java VM.
  • Its port of J9VM includes Apogee's performance-tuned implementations of RTSJ features that must be implemented in a Java VM.
  • It comes with Apogee's JAOT (Just-Ahead-of-Time) compiler instead of the JIT compiler, which is based on IBM's JIT compiler technology enhanced by Apogee for the 'just ahead of time' execution (execution during the J9VM start-up time).
  
  
• Each ME or SE JRE can be provided in a configuration customized for runtime execution on multi-core processors, in which case:
  • Its port of J9VM concurrently executes the multiple Java threads of a given Java application on multiple cores of the target processor.
  • Its JIT compiler produces native (binary) methods for bytecode methods in multiple Java threads, which are concurrently executed on multiple cores of the target processor.
  • The interpreter loop of its port of J9VM and the code generator of its JIT compiler are adapted to work effectively with the multi-threading support provided by the OS.
  
  
• For memory-constrained devices, each ME or SE JRE can be provided in a configuration that can be executed from the flash memory (the XIP execution), as long as a given device has a sufficiently large flash memory with sufficiently fast access time, and the OS running on the device supports the XIP execution.


• IBM's J9VM technology the port of which is included in every ME or SE JRE has been enhanced by Apogee in the following important areas:
  • Its class loader loads more rapidly the JAR files of large Java applications having many Java classes and/or using many C/C++ written native methods.
  • Its JNI (Java Native Interface) invokes more rapidly the C/C++ native methods of Java applications targeted at the JRE and rapidly passes the arguments to/from such methods using the Apogee-added 'fast path' through the JNI.
  • Its bytecode verifier can be turned off in each deployment-ready JRE after the JAR files of all Java applications that will be running on the JRE were verified for correctness.
  
  
• IBM's advanced JIT compiler technology the port of which is included in every and ME and SE JRE (except in case of each RTSJ compliant ME or SE JRE, which has a port of Apogee's JAOT compiler based on IBM's JIT compiler technology) has been enhanced by Apogee in the following important areas:
  • The compiler-produced native (binary) methods are in a 'direct JNI format', which allows their rapid invocation and native execution on the underlying target processor.
  • Its code generator in each port of the JIT technology is optimized to produce the most effective native (binary) code for execution on a given target processor.
  • The JIT technology used in the JAOT compiler also includes a special Apogee-invented 'fuzzy logic' capable of identifying those bytecode methods in each JAR file about to be executed on a given ME or SE JRE that are most suitable for compilation into native (binary) methods.
  
  
• Each ME or SE JRE can be provided with IBM's JLink tool capable of:
  • Analyzing the uses of Java classes and methods in JAR file(s) of a given Java application and in JAR files of Java-written components of JRE (the JAR files of FCL or Harmony, for example).
  • Removing from each such JAR file the Java classes that are not actually used.
  • Removing the bytecode methods that are not actually used from each remaining class.
  • Optionally, creating a single ROMable image, which has only the actually used Java classes of the application and JRE components, and which also includes the executable files of ports of J9VM, JIT compiler, and all other components of the JRE.
  
  
• The 'production quality' release of every ME or SE JRE can optionally be provided with outstanding technical support and maintenance for a very reasonable fee. This support and maintenance covers the following:
  • Timely fixes of bugs and other problems found in JRE components based on IBM's Java technologies or created by Apogee.
  • Timely fixes of bugs and other problems found in ports of components obtained from providers of open-source Java software that cannot be fixed by such providers in reasonable time frames.
  • 'Work-arounds' for critical bugs that cannot be fixed in 48 hours.
  • Bug fixes for bugs found in similar JREs by other Apogee's customers.
  • Updates and minor new releases for the components of JREs based on IBM's Java technologies or created by Apogee. The major new releases of components based on IBM's Java technologies or created by Apogee, as well as the updates and all new releases of components obtained from providers of open-source Java software, can be provided for the additional support fee.
  • Advice on most effective use of each JRE, and on tuning its JIT/JAOT compiler for the best possible runtime performance on customer's Java applications.

Each ME JRE can be provided with OS/processor ports of the following optional components:

• Additional J2ME-compatible Java class libraries from IBM. For example, the Personal Class Library (PCL) compatible with Sun's J2ME Personal Profile.
• IBM's and Apogee's implementations of Java API packages defined by J2ME Java Specification Requests (JSRs). For example: IBM's implementation of JSR-172 XML Support & Web Services package or Apogee's implementation of JSR-82 Bluetooth API.
• Client-side 'runtimes' from IBM or providers of open-source Java software and IBM, as long as each such runtime only uses the J2ME-compatible class libraries and API packages included in a given ME JRE. For example, the Equinox OSGi R4 runtime from Eclipse eRCP (embedded Rich Client Platform).
• Application-level packages from providers of open-source Java software, as long as each such package only uses the J2ME-compatible class libraries and API packages included in a given ME JRE. For example: the log4j package from Apache.org.

• Java class libraries:
  • IBM's Personal Class Library (PCL) of java.applet, java.awt, java.beans, java.rmi, and javax.microedition.xlet API packages compatible with the corresponding packages in Sun's latest J2ME CDC Personal Profile;
    OR
    IBM Personal Basis Class Library (PBCL) of java.awt, java.beans, java.rmi, and javax.microedition.xlet API packages compatible with the corresponding packages in Sun's latest J2ME CDC Personal Basis Profile.

    The OS/processor port of PCL or PBCL comes either with a port of IBM's Universal Graphics Library (UGL), or a port of eSWT (embedded Software Widget Toolkit) from Eclipse eRCP, each of which provides a transition layer between the java.awt APIs of PCL or PBCL and the graphical functions of a low-level graphics library (LLGL) that comes with a given OS. For example, most Linuxes come with the GTK-2 LLGL coupled with the X-Server LLGL. The ports of eSWT are included for OSs not yet targeted by UGL.

  • IBM's JxComm library providing the APIs for serial and parallel communications, compatible with Sun's J2ME Javax.comm API.
  
  
• IBM's implementations of API packages defined by JSRs targeted at the J2ME CDC platform. For example:
  • JSSE (Java Secure Socket Extension, JCE (Java Cryptography Extension), and JAAS (Java Authentication and Authorization Service) optional packages of the Foundation Profile.
  • JSR-66 RMI package.
  • JSR-169 JDBC package that optionally comes with IBM's Database Enabler runtime.
  • PKI, CRYPTO, and APDU pkgs from JSR-177 Security & Trust Services API (SATSA).
  • JSR-172 XML Support & Web Services package.
  
  
• Apogee's implementations of API packages defined by JSRs targeted at the J2ME CDC or CLDC platform. For example:
  • JSR-82 Bluetooth API augmented with a fast native interface for implementing Bluetooth APIs on 'top of low' level Bluetooth stacks that come with targeted devices.
  • JCRMI package from SATSA.
  
  
• IBM's implementations of JSR packages defined by JSRs targeted at the J2ME CLDC platform, adapted by Apogee for use with the J2ME CDC-targeted ME JREs. For example:
  • JSR-120 and JSR-205 Wireless Messaging APIs.
  • JSR-135 Mobile Media API.
  • JSR-179 Mobile Location and JSR-238 Mobile Internalization APIs.
  
  
• Client-side runtimes:
  • The Equinox OSGi R4 runtime from Eclipse eRCP.
  • Other runtimes from eRCP, such as the Configuration Admin Service and Extension Point Framework.
  • The OpenFusion CORBA runtime from PrismTech.
  • Jakarta commons-lang, commons-logging, and xml-commons-external runtime from Apache.org.
  • The RFID runtime from IBM's RFID Data Capture and Delivery product offering.
  • Runtimes for various services from IBM's Micro Environment Toolkit for WebSphere Studio or WebSphere MQ (Servlets, SyncML DS&DM protocols, etc.).
  • The IPv6 (Internet Protocol Version 6) runtime from IBM's WebSphere MQ.
  • MQTT (MQ Telemetry Transport) runtime from IBM's WebSphere MQ.
  • Message MicroBroker runtime from IBM's Lotus Expeditor DE (Desktop Edition).
  
  
• Application-level packages:
  • Xerces XML validating parser from Apache.org.
  • Log4j from Apache.org.
  • Jakarta-regexp implementation of regular expressions from Apache.org.
  • Picollo, a small and fast XML parser from piccolo.sourceforge.net.
  • Jaxen, an event-based X-path parser from jaxen.codehaus.org.
  • Dom4j, an effective and compact XML framework from dom4j.org.
  • Ristretto, a low level Java Mail package from columbamail.org.
  • Xsdlib, a multi-scheme XML validator from Sun's open-source msv.dev.java.net.
  • JMS (Java Message Server) from IBM.
  
  
  Optional components of SE JREs

  Each SE JRE can be provided with the OS/processor ports of the following optional components:

  • Client-side runtimes from providers of open-source Java software, IBM, or other Apogee's partners, each of which can use the ports any Java 5 compatible APIs from Harmony. For example, the J2SE-level Equinox OSGi R4 runtime from Eclipse.org, or the real-time CORBA runtime from PrismTech.
  • Application-level packages from providers of open-source Java software, IBM, or other Apogee's partners, each of which can use the ports of any Java 5 compatible APIs from Harmony. For example, the Tomcat servlet container from Apache.org, or Jetty web server from Mortbay.org.
  • Implementations of Java API packages defined by J2ME JSRs, if there is no API package in Harmony corresponding to a given JSR-defined package, or if the corresponding Harmony package has significantly lower performance. For example, Apogee's implementation of the JSR-82 Bluetooth API.
  
  
  Specifically, the optional components available for SE JREs are as follows:
  • All the client-side runtimes and application-level packages available for ME JREs. (See above.)
  • Tomcat Servlet Container from Apache.org.
  • Jetty web server from Mortbay.com.
  • DOM.Xpath packages from W3.org.
  • JSP (Java Server Pages) package and runtime from Sun's open-source Glassfish webtier.
  
  
  Support for graphics by ME and SE JREs

  Each graphics-supporting ME JRE includes:

  • A port of IBM's PCL or PBCL with its J2ME CDC-compatible java.awt package.
  • Either a port of IBM's Universal Graphics Library (UGL) or, in case of the OS that is not yet supported by UGL, a port of eSWT (embedded Software Widget Toolkit) from Eclipse eRCP.

    UGL as well as eSWT provides a transition layer between java.awt APIs of PCL or PBCL and low-level graphics library (LLGL) that comes with the OS/processor platform targeted by ME JRE, such as: GTK2 coupled with X-Server that comes with most Linuxes, GDI that comes with Windows Mobile or Windows CE, or OpenGL. Note that UGL is more suitable than eSWT for retargeting at various LLGLs, and each of its ports is optimized by Apogee to work effectively with the graphical functions of a given LLGL.

    Each port of eSWT includes: (i) Apogee's 'front-end' layer that makes the eSWT widgets work more effectively with the java.awt APIs of PCL or PBCL; and (ii) Apogee's fast mapping from eSWT widgets to graphical functions of a given LLGL.

  The resulting 'AWT --> UGL --> LLGL' or 'AWT --> eSWT --> LLGL' graphical stack is tuned for the highest possible performance on graphical parts of customer's Java applications.

  Each graphics-supporting SE JRE includes:

  • Ports of java.awt and Java2D packages from the Harmony class library.
  • Ports of javax.swing and java.nio packages from Harmony, if the Java applications that will be running on the JRE have the graphics created with Sun's Swing widget toolkit.
  • Either a port of X-Server LLGL provided by a customer or created by Apogee, or a DirectFB runtime library (RTL) provided by a customer.
  
  
  The ports of java.awt, Java2D, and (if used) javax.swing Harmony packages are enhanced to work effectively with the port of X-Server or DirectFB RTL, and the resulting 'AWT --> X-Server' or 'AWT --> DirectFB' graphical stack is tuned for the highest possible performance on graphical parts of customer's Java applications.

  Please note that Apogee's graphics-supporting SE JREs are the first and, thus far, the only ones that have the high-level java.awt, Java2D, and (if used) javax.swing packages from Harmony working directly with the DirectFB RTLs.

  RTSJ-compliant ME and SE JREs

  Each ME or SE JRE can be provided in a configuration compliant with the Real-Time Specification for Java (and certified as such by the RTSJ expert group), in which case:

  • It includes a port of Apogee's RTSJ class library providing the performance-optimized implementations of RTSJ features that do not have to be implemented in a Java VM.
  • It comes with Apogee's JAOT compiler based on IBM's JIT compiler technology, to which Apogee added a special 'fuzzy logic' for finding such bytecode methods in each Java application about to be executed on the JRE that are most suitable for compilation into native methods. Note that the JAOT compiler is essentially a JIT compiler invoked during the J9VM start-up time. It is used instead of the JIT compiler, which is too non-deterministic for use in RTSJ-compliant JREs.
  • Its port of J9VM includes:
    • Apogee's performance-tuned implementations of RTSJ features that must be implemented in a Java VM (for example, handling of scoped memories).
    • Apogee's real-time garbage collector, which is more effective then the Metronome real-time garbage collector that comes with IBM's RTSJ-compliant J2SE-compatible JREs.
  • Its ports of all other components are enhanced for RTSJ compliance.
  
  
  Apogee's RTSJ-compliant ME JREs are the only ones targeted at devices based on embedded systems that have been officially certified by RTSJ expert group as compliant with RTSJ.

  ME and SE JREs for multi-core target platforms

  Each ME or SE JRE can be upgraded to effectively execute multi-threaded Java applications on multiple cores of a given target processor. Specifically:

  • Its port of J9VM concurrently executes the parallel Java threads of a given application on available cores of the target processor.
  • Its JIT or JAOT compiler produces binary forms of suitable Java methods in parallel Java threads of a given application, which are executed concurrently on available cores of the target processor.
  • The interpreter loop of its port of J9VM has been enhanced for:
    • Minimizing the overhead of starting and terminating the Java threads, and communicating between the threads during their execution.
    • Minimizing the garbage collection overhead by 'pre-collecting' garbage on the processor cores that are not fully utilized by running parallel threads.
    • Working effectively with the underlying multi-threading support of a given OS, and minimizing the overhead of switching among the multiple processor cores.
  • The code generator of its JIT or JAOT compiler has been enhanced for producing native code that works effectively with the underlying multi-threading support of a given OS.

  ME and SE JREs for RFID devices

  Each ME or SE JRE can be provided in a configuration allowing its effective use on RFID readers and 'edge' servers. Specifically, each RFID-supporting ME JRE includes, at the least, the OS/processor ports of the following components:

  • J9VM, JIT compiler, FCL, and implementations of JSSE, JCE, JAAS, and Web Services API packages.
  • RFID runtime from IBM's RFID Data Capture and Delivery product offering that facilitates various RFID functions on the devices it is running on.
  • Apogee's LLRP adaptor that facilitates the use of Java applications conforming to LLRP (Low Level Reader Protocol), a common I/O protocol defined for the RFID devices by EPC Global consortium.
  • Equinox OSGi R4 runtime from Eclipse eRCP.
  • IBM's JxComm class library facilitating serial and parallel communications to/from the device having the JRE installed on it.
  
  
  Each RFID-supporting SE JRE includes, at the least, the OS/processor ports of the following components:
  • J9VM, JIT compiler, and a subset of Harmony providing: (i) API packages equivalent to J2ME JSSE, JCE, JAAS, and Web Services API packages; and (ii) API packages needed by IBM's RFID runtime, namely java.io, java.lang, java.net, java.security, java.text, and java.util.
  • RFID runtime from IBM's RFID Data Capture and Delivery product offering.
  • Apogee's LLRP adaptor that facilitates the use of Java applications conforming to LLRP.
  • Equinox OSGi R4 runtime from Eclipse eRCP.
  • IBM's JxComm class library facilitating serial and parallel communications to/from the device having the JRE installed on it.
  Please, contact Apogee by email or phone for more information on features and capabilities of Aphelion JREs.