| |
The aim of this project is to analyze the portability of
the .NET platform and the Internet revolution into the world of embedded
systems. Two types of systems could be studied: those with OS support
and those with minimum or non-existent OS support. JIT compilation, runtime
interpretation as well as hardware issues must be addressed. Our final
goal would be to devise a hardware implementation of the .NET CLR so that
CLI byte-code could be run natively.
Embedded
systems
The expression embedded processor refers to the requirement of being
embedded into a general system without being really visible to the end-user.
Recently, the market for 32-bit embedded processors has been growing.
Embedded processors can be found in appliances (television and VCRs, stereos),
computers and computer equipment (laser printers, modems, disk drives),
automobiles (engine control, diagnostics, climate control), environmental
control (greenhouse, factory, home), instrumentation, aerospace, and thousands
of other uses. In the future they may be used in personal mobile computers,
that integrate portable computers with cellular phones, digital cameras,
video game players, etc. This trend leads to an increasing demand for
32-bit embedded processors and related system development tools.
Programmable logic
Programmable logic devices (PLDs)
are semiconductor chips that can be customized and programmed using software
tools. Built on the premise that time-to-market and flexibility are key
elements for success. PLDs have evolved in response to the need of building
increasingly complex electronic systems. From simple, general-purpose
logic integration to complex devices that incorporate logic, memory, high-speed
I/O functions, and embedded processors. PLDs now offer the same system
functionality as application-specific integrated circuits (ASICs), which
allow the implementation of a complete system on a chip (SoC) with both
embedded processing and Internet capabilities.
Advances in programming
languages, compilers and program execution
Advances in programming languages, compilers and program execution Current
programming languages and development platforms have evolved significantly
in recent years. Driven by the constant evolution on networking, telephony,
embedded systems, etc., programming technologies have moved from the traditional
platform-specific languages and compilers where portability was not an
issue, to a new scenario where multiple programming languages can be combined
and must run over a bunch of different platforms with different processor
architectures and operating systems. Sun Microsystems has leveraged this
field with its Java technology for almost 10 years. However, nowadays
Microsoft's .NET platform appears to be the most innovative and promising
technology to achieve true interoperability between programming languages,
and true portability over different hardware and operating system platforms.
The Virtual Object System (VOS) implemented by the Common Intermediate
Language (CLI), and the Common Language Runtime (CLR) are the major contributions
of the .NET technology.
Motivation
A big gap exists between the aforementioned technologies, therefore a
good opportunity for research exists. System developers that use embedded
processors keep using proprietary tools of the manufacturer in order to
program the software that runs on those devices. Although these tools
are well suited for that purpose, the variety of offered languages is
very poor. Instead, it would be nice that they could program those designs
using common standard programming tools such as VisualStudio. Moreover,
the .NET technology may truly enable the embedded Internet revolution,
providing a flexible and common platform for this technology. No known
support exists for .NET in embedded architectures, neither through CLR
implementations nor through JIT compilation into native code. For example,
it is unknown the performance achievable by a common embedded processor
executing CLI over a port of the CLR, or directly executing JITed code.
Also it is interesting to study which are the parameters that constraint
the execution of a stack-oriented architecture, like CLR, over a general
purpose processor, and what modifications of the existing processor architectures
can be incorporated to improve performance. Current technology offers
sufficient potential for hardware implementations of CLR in such a way
that CLI byte-code could be extecuted natively. In a similar vein, Sun
Microsystems developed his own hardware implementation of the Java Virtual
Machine, known as picoJava, targeted for Internet appliances. More immediately,
execution speed-ups could be achieved by adapting the architectures of
current embedded processors to the CLR execution paradigm.
Objectives
The general objective of the project is to study the viability of a hardware
implementation of the CLR that can execute CLI byte-code natively. Since
this is a too ambitious goal we restrict ourselves to a set of more realistic
intermediate goals. The particular objectives for this one-year project
are the following:
 |
Study the JIT compilation for embedded
processors, including high performance processors like ARM with extensive
OS support, as well as processors used in rapid
prototyping systems with small or non-existing OS support. |
|
Modify the architecture of a given processor
to improve execution of native code coming from JIT compilation of
CLI. |
|
Study the viability of a processor that
partially (or completely) implements the .NET CLR. Given the complexity
of the VOS object system and the .NET virtual machine, it is not intended,
at first, to cover the entire CLR specification. Instead, a significant
subset will be chosen, that could be used to run simple programs and
interact with hardware devices in an embedded environment. |
Besides simply interpreting and executing byte-code instructions, the
.NET CLR performs many other tasks, such as: loading classes, object and
heap management, garbage collection, thread management, etc. Therefore,
the CLR is quite complex since it incorporates tasks normally performed
by the OS or the compilers. In consequence, these requirements make its
implementation in hardware a difficult task. However, the good results
achieved with picoJava by SUN , that proved 5 times faster program execution,
motivate this part of the project.
Potential Projects
Among others, the following projects have been distinguished.
|
Viability of the .NET platform into embedded
processors Analyze which parts of Virtual Machine (Rotor) can be successfully
ported into embedded processor with limited or non-existing OS support.
|
|
JIT for Altera's Nios Embedded processor Create a JIT for a specific
embedded processors without OS support. Quantify the execution performance
analyzed on a real hardware development platform. |
|
Hardware support for JITed code execution
Identify the critical elements in the Nios
embedded processor architecture that may improve the execution of
the JITed code. Design and implement partial modifications to the
existing architecture and quantify the benefits. |
|
JIT for ARM embedded processor Create
a JIT for the high performance ARM embedded processor. Evaluate the
execution performance of the JITed compared to natively compiled languages
like C. Identify the sources of potential inefficiencies. |
|
Viability of a CLR hardware implementation
Study the viability of a processor that implements a significant subset
of the .NET CLR. |
Links
Plataforma
.NET Platform
Implementacion
Hardware de Java
|
|
