ITR: Collaborative Research: Morphable Software Sevices: Self-Modifying Programs for Distributed Embedded Systems
Description: Future embedded system applications and infrastructures will be
increasingly dynamic. Moreover, the devices used in such infrastructures
will vary widely, from sensors and embedded devices, to handhelds, to high end
server systems, all of which interact continuously in order to collect,
collate, and deliver information from where it is produced to where it is
needed. This project addresses the dynamic nature of distributed embedded
systems, by developing new information technologies that integrate across
multiple areas of Computer Science, including computer architecture, operating
and real-time systems, compilers, and middleware. The key intent is to create
morphable embedded services, that is, services that continuously self-modify
and adapt in order to meet dynamic application needs and environmental/resource
constraints, including power budgets, end-to-end quality of service (QoS) guarantees
(e.g., timing constraints), and security constraints.
There are many Useful examples of morphable services. In limited forms, they
are already present in today's cellphone platforms, for instance, where end users
dynamically download new rings or acquire new games (possibly displacing existing
ones), etc. Service morphing, however, goes much beyond such configuration
capabilities. Imagine a cellphone, for example, which dynamically morphs into
an portable wand, using its sensing (e.g., its built-in camera) and
communication abilities (e.g., by interacting with other nearby phones)
to guide its owner out of a disaster site. Then, in contrast to such
functionality-centric morphing, consider this cellphone drawing on the
power of nearby server systems (or other phones) to provide suitable levels
of service to its user, despite the fact that its power is running low. This
can be done, for instance, by dynamically offloading services onto other
platforms, by (re)partitioning services across the device and cooperating server
systems, and/or by deploying more power-efficient and perhaps, less graphics-capable
service code to the phone itself. Another interesting aspect of our work is its
ability to go beyond performance and power as the only critical elements of future
systems. With our approach, for instance, compiler methods and middleware can be used
to enhance information security rather than system performance. This can be done
by scattering critical application state to reduce its exposure to
external intrusions. As a result, information security can become an integral
element of the QoS needs of applications.
A concrete example of security-focused service morphing is to `scatter'
critical and vulnerable values across multiple cooperating distributed
platforms and to `assemble' them only to the extent needed by the application
under compiler control. Moreover, when the last use of the `assembled'
value is complete, the `assembled' value is destroyed. Each use of an `assembled' value is verified by compiler-generated code that authenticates it. For example, consider the use of last four digits of the social security number
used for authenticating a transaction. The entire social security number will
never be stored in a memory location as a value (that could be hacked into).
The value will be scattered in a form known only to the compiler which it will
then use to `assemble' the value just in time only for the extent of the use.
The different service morphing techniques to be developed in this research
include dynamic component (re)deployment, (re)specialization, and (re)partitioning.
Such actions are supported by system-level mechanisms that efficiently carry the
performance, usage, and requirements information needed for runtime component morphing,
principally addressing components' processing and communication actions.
The intent is for self-modifying components to be able to acquire runtime
information about current resource availabilities and Quality of Service
demands. While developing these software technologies, we will concurrently
explore new application-specific techniques and methods that take advantage
of morphable software services, targeting remote sensing and autonomous robotics
applications. Finally, while most of our work will utilize current embedded
systems platforms, using XScale boards, we will also consider how to
further improve hardware platforms to better enable morphable services.
Such work essentially broadens the optimization space in which morphable
services are able to operate.
Our technical approach integrates across multiple CS disciplines, by exploiting,
for instance, detailed knowledge about computer architecture (e.g., power usage
related to memory footprint) to develop compiler techniques that dynamically generate
code with functionality and the performance/power profiles more suitable to
current application needs. Compiler-level and architectural knowledge is maintained
as meta-information at the middleware level, and lightweight middleware dynamically
deploys newly morphed code to target platforms. Kernel-level mechanisms collect and
distribute the resource information needed for such actions. They also help integrate
the application-level with the system-level actions being taken, the latter being
particularly important when satisfying certain end-to-end constraints
(e.g., timing or power constraints) desired by distributed embedded applications.
A key goal of this research is to demonstrate the importance and utility of
morphable services for critical applications. This implies the need to
jointly develop application techniques and ideas with morphable service technologies.
By grounding our research in a challenging application domain, autonomous robots used in
emergency management situations, our technological solutions must ``close the loop'',
integrating system-level information about resource constraints, with
middleware-level options to morph services, with application-level opportunities
for making tradeoffs and choices about how to best meet current requirements.
The result are systems in which changed application needs result in new code
modules deployed and specialized to meet these needs, jointly with changes in
underlying system configurations and properties. In other words, applications and
systems are continuously `morphed' to best match end user requirements.
A concrete example of extending application-level research to exploit
service morphing is to extend mission-centric notions of `value' in autonomous
robots. In robotics, `value' captures an individual robot's contribution to a mission
undertaken by a robot team, and `value' helps a robot determine its next actions.
Our new research will extend these solutions: instead of considering only
movement alternatives, the robots will also consider the `values' of
other activities like communication, computation and observation. This approach
depends significantly on other components of this proposal, namely QoS
management and cooperative service morphing, so that the communication links
available to a robot team and the CPU power needed for interpreting distributed
sensor inputs can be deployed appropriately.
Funder: National Science Foundation
Amount: $166,200
Funding type: grant
Funder scheme: Continuing Grant
Start date: 2003-10-01
End date: 2007-09-30
Investigator: Rajiv Gupta (lead)
Institution: University of Arizona
Subfield: Software
Field: Computer Science
Domain: Physical Sciences
Funded outputs count: 2
Funder award ID: 0324969
OpenAlex ID: G3252016154
