ITR: Collaborative Research: Morphable Software Services: Self-Modifying Programs for Distributed Embedded Systems

Georgia Tech Research Corporation, Atlanta GA

Investigators

Abstract

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.