Download INSIGNIA`S Accelerated JAVA™ Solutions for Internet Appliances

JEODE™
Why the Jeode Platform?
Most implementations of Java™
technology have been functionally
incomplete, too slow, too big, or too
unpredictable for use in Internet
appliances and embedded devices.
Insignia® has overcome these barriers
with the Jeode platform, its
accelerated implementation of the
PersonalJava™ and EmbeddedJava™
specifications tailored for Internet
appliances and embedded devices.
The Jeode platform provides:
• A full-featured implementation
compatible with Sun’s
PersonalJava and
EmbeddedJava
specifications
• Industry leading
accelerated performance
and efficient memory
utilization
• Configurability and tunability to meet
the diverse needs of Internet
appliance and embedded device
developers
• A turn-key solution already
ported and tested on popular
RTOS/processor combinations
• Worldclass support, training,
consulting, customization and
development tools
Using Java technology for Internet
appliance and embedded device
development
The advantages of the Java programming
language are well known. More than just a
programming language, the Java platform
provides a suitable runtime environment
to allow dynamic extensions to
running applications. Java technology
was designed, and is the leading platform
today, for developing Internet-based
applications. Java technology extends the
utility of networks, such as the Internet, by
providing an efficient means of storing and
distributing dynamic and extensible
functionality to networked computing
devices. For example, Java technology
enables developers of digital set-top boxes
to easily comply with federal regulations to
ensure that set-top boxes can be
maintained and upgraded over the network.
INSIGNIA'S
A C C E L E R AT E D J AVA ™
SOLUTIONS FOR
I NTERNET APPLIANCES
AND EMBEDDED
DEVICES
TM
I N S I G N I A ' S J E O D E P L AT F O R M
A L L O W S D E V E L O P E R S T O C R E AT E
A P P L I C AT I O N S
FOR INTERNET APPLIANCES AND
EMBEDDED DEVICES USING
P E R S O N A L J AVA ™ - A N D
E M B E D D E D J AVA ™ - C O M PAT I B L E
T E C H N O L O G Y.
Other examples of Internet appliances
and embedded devices that benefit from
Java technology include smart storage
systems, personal digital assistants
(PDAs), smart phones, automobile
navigation and multimedia systems,
data
and
telecommunications
infrastructure equipment, point-of-sale
and vertical application devices.
The Jeode platform makes Java
technology viable for Internet
appliance and embedded device
development
The Jeode platform is integrated with a
suite of tuning and programming
tools to help developers write and
implement Java programs on resourceconstrained Internet appliances and
embedded devices. The Jeode
development environment, which
includes the Jeode Embedded Virtual
Machine™ (EVM™), allows software
developers to use Java technology as
the foundation for reliable, efficient
and
predictable
Internet
appliances
and
embedded
devices.
The Jeode platform is comprised of
two primary components, the
development tool suite, and the
runtime environment: JeodeSuite and
JeodeRuntime. JeodeSuite consists
of the JeodeBuild tools for editing,
compiling and browsing Java
applications, and the JeodeDebug
runtime debug utilities and source
level
debugger.
Also,
the
JeodeConfigurator contains an event
monitor and a memory use analyzer
that provide an easy way to tune and
configure the EVM for any device.
The
runtime
environment,
JeodeRuntime, consists of the highly
configurable EVM, and the JeodeClass
embedded class libraries. The Jeode
platform and its components are
shown in the following diagram:
meet the performance requirements for Internet
appliances and embedded devices, the Jeode
EVM provides a sophisticated combination of
interpretation and dynamic compilation. The
EVM's adaptive dynamic compiler optimizes
these critical tradeoffs:
• What to compile
• When to compile
• How to compile
• How to delete compiled code
The Jeode platform is designed to be
compatible with third party tools for
developing Java applications. Editing,
compiling, browsing and debugging the Java
application is done on the host computer.
Developers can use the tools of their choice to
perform these functions on the development
host. Special integration exists between the
Jeode platform and Metrowerks CodeWarrior
Integrated Development Environment (IDE). A
CodeWarrior plug-in is provided as part of the
Jeode installation, offering Jeode Embedded
Virtual Machine-specific functionality. Once
the application is compiled on the host, the
bytecodes can be downloaded by the
JeodeConfigurator to be executed on the target
device. Using the CodeWarrior debugging
environment on the host, the Java application
can be executed and debugged on the target
device. The Jeode event monitor and memory
usage analyzer (executed on the host by using
JeodeMonitor) is a simple yet powerful tool for
balancing the performance and memory usage
on the target device.
Standard interfaces, such as JVMDI/JDWP,
are also supported to enable developers to
select other third party tools for debugging
Java applications on the target from the host.
The Jeode Embedded Virtual Machine
The Jeode platform includes the highly
configurable and tunable Embedded Virtual
Machine incorporating patented technologies
that optimize the performance of application
software in resource-constrained Internet
appliances and embedded devices.
The EVM uses unique technologies, including
adaptive optimizing dynamic compilation for
accelerated performance, and concurrent
precise garbage collection for predictable,
consistent behavior and efficient memory
utilization. Developers have the ability to balance
and optimize performance, size and
predictability to meet application and system
requirements.
The EVM provides the ability to optimize
size, speed and predictability
The EVM is a full-featured Java-compatible
virtual machine and supports embedded class
libraries designed to be compatible with Sun’s
1.1.1 PersonalJava and 1.0.3 EmbeddedJava
specifications. (This is roughly equivalent to
Sun’s 1.1.7b JDK.)
The Jeode EVM provides:
• Certified PersonalJava and
EmbeddedJava compatibility
• Accelerated performance via adaptive
dynamic compilation
• Predictability and efficient memory
usage via precise, concurrent garbage
collection and dynamic class loading
• Support for Java class libraries
• Standard interfaces — e.g., JNI, JVMDI/JDWP
• AWT support
• Invocation API that allows the Jeode
EVM to be called from any application
• Support for Zip and JAR compressed
files
Optimizing Performance
Most implementations of the Java platform are
interpreted, and are therefore too slow for many
Internet appliances and embedded devices.
Just-in-time (JIT) compilation technology has
been developed which is suitable for the
desktop environment but is inappropriate for
Internet appliance and embedded classes of
devices. Typical JIT implementations require
large amounts of memory, disk storage, and
usually virtual memory for paging segments of
dynamically compiled code. JIT compilers can
also cause unpredictable delays during
compilation and consume an unbounded
amount of physical and virtual memory.
Internet appliances and embedded devices
require consistent performance that must be
balanced with an efficient use of limited
resources and predictable system behavior. To
This adaptive dynamic compiler technology
differs from JIT compiler technology in that it
requires less memory, requires no disk
storage for virtual memory, and dynamically
compiles only the code that represents the
current performance bottlenecks in the
application and/or accelerates critical aspects
of an application’s code. The remainder of the
application code runs interpreted. As the
application runs, the EVM determines which
code segments are executing most frequently,
then compiles and stores them into the
configured amount of code buffer memory.
Once the allotted code buffers are used, the
EVM may recycle the buffers to optimize
performance in the given footprint.
Recent independent benchmarks running
the
industry-standard
Embedded
CaffeineMark™ 3.0 confirmed that the Jeode
EVM executes Java applications on average
six times faster than interpretive VMs.
Minimizing Size
With the EVM and the JeodeSuite tools, developers
can minimize the amount of memory that is needed
for the application to run without having to
compromise performance. Developers can reduce
the memory needed by the virtual machine to run a
Java application, and also manage memory to
maximize performance within the constraints of the
available resources. The Jeode build-time tools
include JeodeConfigurator to assist developers in
specifying the parameters for a specific
implementation of the Embedded Virtual Machine.
Size can be configured to make functionality and
performance trade-offs for each specific application.
The actual ROM size required for the
Embedded Virtual Machine can vary
anywhere from approximately 360 KB to
2.7MB for all class libraries with English
language support, to approximately 5 MB
6000
5000
Size in KB
Components of the Jeode platform
4000
3000
2000
1000
0
Intepreted VM
evm
io/lang/net/utl
compiler
Jeode ROM usage
All classes
except AWT
class libraries
All classes
AWT
Full International
support
international
for all class libraries with full international
language
support.
ROM
footprint
requirements can easily be balanced with
functionality and performance.
Balancing Predictability and Consistency
The Jeode EVM offers predictable and
consistent performance coupled with
efficient memory utilization. The behavior
of an Internet appliance or embedded
device application needs to be reliable and
predictable. Consistent performance
across varying classes of devices is also
important. Unscheduled pauses in the
application’s execution are unacceptable in
most Internet appliance or embedded
device environments. Predictability is
largely determined by the “garbage
collection” strategy that is used to manage
memory. The following figure illustrates
three typical ways of implementing garbage
collection.
Also, the Jeode EVM implements precise (or
accurate) garbage collection that frees up all
unreferenced objects, and avoids memory
leaks. By contrast, conservative garbage
collection, which is an alternative approach,
may not release all unreferenced objects and
thus may experience unpredictable behavior,
due to out-of-memory problems resulting
from memory leaks.
To further improve predictability and
consistency, the adaptive dynamic compiler
operates as a thread and will be pre-empted
by any higher priority threads in the system.
In addition, the amount of memory used by
the EVM can be bounded, and the usage of
memory may adapt dynamically depending
on the current needs of the application.
Also, each of the EVM components will
gracefully handle any failures to acquire
more memory. If a memory request fails,
for example, the EVM may generate an
exception that can be appropriately
managed, rather than cause the system to
crash.
Finally, each Java thread is mapped to an
underlying thread in the real-time operating
system, providing improved integration
with native threads and tighter synergy
with the RTOS scheduler.
Garbage collection implementations
The “batch” garbage collector runs a
complete batch cycle, and cannot be preempted, which will render Java technology
unsuitable for the Internet appliance or
embedded device application (i.e.,
unpredictable). The “incremental” garbage
collector runs in a stepwise fashion and
should lead to more predictable behavior
than a batch garbage collector. However, the
incremental garbage collector may not be
pre-emptible and may therefore still block
the execution of the Internet appliance or
embedded device application, a condition
that leads to unpredictable behavior.
The Jeode EVM is Configurable
and Tunable
The Jeode EVM can be configured and tuned
in several different ways to assist developers
in defining a specific implementation of the
EVM that is optimized for a particular
Internet appliance or embedded device. For
example, developers can specify the
maximum system memory, maximum heap
size, maximum stack size, and several
parameters associated with dynamic
compilation.
The
JeodeConfigurator
interface is shown in the following
screenshot:
JAVA CLASS L IBRARIES
The Jeode platform includes the following
Java class libraries that are defined in the
1.1.1 PersonalJava, and 1.0.3 EmbeddedJava
specifications:
java.io – sophisticated input and output, using
standard i/o, memory buffers and files
java.util – manipulation of dates, random
numbers and data structures (dictionaries,
stacks, hash tables, vectors)
java.lang – core Java API classes such as
Object and Class
java.net – powerful and flexible infrastructure for
networking
java.util.zip – data compression and
decompression
java.lang.reflect – the Reflection API: allows the
Java program to inspect and manipulate its
structure and classes
java.math – arbitrary precision integer and
floating point arithmetic
java.text – locale-specific format conversions for
numbers, date and time
java.rmi – remote method invocation
java.security – encryption and computation of
digital signatures
java.sql – Java Database Connectivity: sending
SQL queries and result retrieval
java.beans – creation and usage of embeddable,
reusable software components
java.applet – support for implementation of applets
(Java programs integrated into web pages)
java.awt – Abstract Window Toolkit: numerous
classes that support graphical program
development
Legend
Optional
Required
No Exposed APIs
JDBC
Java Applet
RMI
JDBC
Security (advanced)
RMI
The Jeode EVM implements fully concurrent
garbage collection technology, and provides
memory compaction to eliminate memory
fragmentation. The garbage collector runs
as a pre-emptible thread and its priority can
be set by the application. And because of its
implementation as a fully concurrent thread,
Jeode platform garbage collection adds
minimal overhead to the context switch time
when switching to a higher priority
application thread.
AWT
Security (advanced)
Networking
Personal AWT
Java IO
Networking
Java Beans
Developers can easily specify critical EVM
parameters using the JeodeConfigurator
Once developers have set the parameters
through this interface, they simply instruct
the JeodeConfigurator to create the
specified configuration of the EVM.
Java IO
Java Virtual Machine
Java Beans
Required Java Classes
Java Virtual Machine
Verifier
Java Virtual Machine
Required Java Classes
EmbeddedJava API
PersonalJava API
FEATURES OF THE JEODE PLATFORM
The EVM can be highly instrumented
to provide helpful diagnostic and
debugging insights into the EVM
itself. Developers can observe the
application’s behavior as it executes,
relative to parameters that they
selected to configure and tune the
EVM. They can view the amount of
heap that was used during execution,
and watch the change in heap size as
the garbage collector runs to bound
the amount of heap that is actually
consumed. The system memory used
and total stack space are also
viewable.
Developers can also observe the
memory that is consumed during
dynamic compilation.
The Jeode platform is:
■ Fast
• Adaptive dynamic compilation for accelerated performance in a
small memory footprint
• An average of six times faster than interpretive VMs
■ Compatible
• Fully compatible with Sun’s 1.1.1 PersonalJava and
1.0.3 EmbeddedJava specifications, including the Java
runtime environment and Class Libraries
• A “Sun Authorized Virtual Machine”
TM
■ Small
• ROM footprint from approximately 360KB to 2.7MB (full English language
support) or 5 MB (full international language support)
■ Predictable
• Precise, concurrent garbage collection, which is pre-emptible
• Asynchronous compilation, which is pre-emptible
■ Configurable
• Scaleable within system constraints (RAM usage can be bounded)
■ Available
• Shipping in binary form with optional source code access
• Individual project and multi-project use license options available
• Evaluation, annual or perpetual licenses available
■ Portable
• Well-defined APIs enabling rapid ports to new operating systems
• Easily migrated to new processors
JeodeConfigurator provides insights
into optimizing the EVM
If they decide that certain parameters
need additional adjustment, they can
repeat the process and configure and
test another version of the EVM. Using
this process, developers are able to
gain valuable information required to
optimize the EVM and their Java
applications for their specific Internet
appliance or embedded device.
The Jeode platform is the solution
The Jeode platform is the solution for
developing and implementing Java
applications in Internet appliances and
embedded devices. The Jeode platform is
integrated with Metrowerks CodeWarrior
Integrated Development Environment for
editing, compiling, browsing and
debugging the Java application on the
host, and doing further debugging on the
target device. The Jeode platform also
provides
JeodeConfigurator
for
configuring the EVM and for examining
the behavior of the Java application and
the EVM. This includes an event monitor
and memory use analyzer. In addition, the
EVM supports the standard interfaces,
JVMDI/JDWP for integration with other
third party runtime and build-time tools.
■ Extensive Tools Support
• Includes JeodeConfigurator to monitor events, analyze memory usage
and tailor the EVM
• Integrated with CodeWarrior from Metrowerks Inc., a Motorola company
• Provides JVMDI and JDWP standard debugging interfaces to support
third party tools
Insignia Solution’s Jeode platform was
the first independently developed Java
virtual machine to earn the right to
display the “Sun Authorized Virtual
Machine” logo signifying full compatibility
with the PersonalJava platform and the
EmbeddedJava technology specifications.
Leveraging over 12 years of experience in
implementing virtual machines, Insignia
Solutions brings unrivaled technology and
leadership to the Java, internet appliance
and embedded device markets.
The specialized technologies delivered
with the Jeode platform and its EVM
provide developers the benefits of the
Java technology, in an environment that
is fully Java-compatible, fast enough,
small enough, predictable enough, and
consistent enough for any Internet
appliance or embedded device
development projects.
Availability
Jeode development is currently
supported on Windows NT host
computers. Target platforms currently
supported include Windows NT/x86,
Windows CE/MIPS, Windows CE/SH,
VxWorks/PowerPC and Linux/ARM.
Additional platforms are scheduled, such
as pSOS/PowerPC and ITRON/PowerPC.
Custom porting services or source code
licensing options are available to
expedite porting to new platforms that
are required by customers.
About Insignia Solutions®
Insignia Solutions is the leading provider of
accelerated Java solutions that dynamically
optimize the use of available system resources.
The Jeode platform is Insignia’s accelerated
implementation of the PersonalJava and
EmbeddedJava specifications tailored for Internet
appliances and embedded devices. Insignia
Solutions was founded in 1986, is publicly-held,
and has headquarters in Fremont, California, and
its main R&D facilities in High Wycombe,
England. Sales and marketing functions are
located in Fremont and High Wycombe.
Insignia Solutions
41300 Christy Street
Fremont, CA 94538-3115
Phone: (800) 848-7677
Phone: (510) 360-3700
Fax:
(510) 360-3701
Insignia Solutions
Insignia House
Mercury Centre
Wycombe Lane
Wooburn Green, High Wycombe
Buckinghamshire, HP10 0HH, United Kingdom
Phone: +44 (0) 1628 539 500
Fax:
+44 (0) 1628 539 501
Insignia and Insignia Solutions are registered trademarks and Jeode, Embedded Virtual
Machine, and EVM are trademarks of Insignia Solutions, Inc. Sun, Java, EmbeddedJava and
PersonalJava are trademarks of Sun Microsystems, Inc.. CaffeineMark is a trademark of
Pendragon Software. All other trademarks are the property of their respective holders.
©2000 Insignia Solutions, plc. All rights reserved. Specifications subject to change without notice.
Insignia Solutions
Kamiya-cho Mori Building, 14th Floor
4-3-20, Toranomon, Minato-ku
Tokyo, Japan 105-0001
Phone: +81 3 5404 3440
Fax: +81 3 5404 3484
Technical Support: www.jeode.insignia.com/support
Email: [email protected]
Web: http://www.insignia.com
NASDAQ: INSGY