Shweta Shetty

Systems integration of large scale autonomic systems using multiple domain specific modeling languages

Software design, development and maintenance for large scale systems has been one of the most difficult and expensive phases of the software development life cycle. Design and maintenance is especially difficult when the system includes autonomic features. As the system size and variety of autonomic behaviors scale up, it increases the chance of many unexpected and unwanted interactions. Separate design tools can hide these potential interactions. To face these challenges, we propose an autonomic system integration platform where holistic design models capture system structure, target system resources, and autonomic behavior. The fault mitigative, autonomic behavior can be explicitly coupled to the components and underlying resources of the system. System generation technology is used to create the software that implements these coupled specifications, including communication between components with custom data type marshalling and demarshalling, system startup and configuration, fault tolerant behavior, and autonomic procedures for self-correction. This modeling schema, along with the tools to generate the various system components are described in this paper.

Modeling and generation tools for large-scale, real-time embedded systems

High energy physics experiments require very large, real-time computation. Furthermore, the computers that implement on-line processing must be very reliable, due to the large cost of operating the facilities and the potential for loss of irreplaceable data. Standard, redundant fault tolerance approaches are not appropriate due to system costs (Fault handling is limited to 10% overhead). Adaptive, fault-mitigation approaches must be used instead. In this paper, we describe a set of tools for specifying and implementing user-defined adaptation algorithms, using model-based representation for specification and software synthesis for implementation.

Autonomic fault mitigation in embedded systems

Autonomy, particularly from a maintenance and fault-management perspective, is an increasingly desirable feature in embedded (and non-embedded) computer systems. The driving factors are several-including increasing pervasiveness of computer systems, cost of failures which could potentially be catastrophic in a wide variety of critical systems, and increasing cost and strain on resources in maintaining systems. A trigger system employed in real-time filtering of particle-collision data is a particularly challenging example of a class of large-scale real-time embedded systems that demand a high degree of fault resilience, due to the large cost of operating the facilities and the potential for loss of irreplaceable data. Traditional redundancy-based approaches are not available due to the limited fault-tolerance budget above the system cost. This paper presents an approach based on model integrated computing that provides a set of tools for the system developer to specify, simulate, and synthesize autonomous fault-mitigative behaviors. A hierarchical, role-based organization of fault managers cleanly delineates the data-processing interactions in the system from the fault-mitigative control interactions. The fault-mitigative behaviors, analogous to autonomous biological systems, are characterized as (1) reflex actions-highly autonomous, localized, and uncoordinated response emanating from a single fault manager at any level of hierarchy, and (2) healing actions-highly coordinated behavior implemented with a sequence of interactions between multiple fault managers. The strength of the approach lies in the specification of these behaviors as coordinated interacting hierarchical concurrent finite-state machines, which makes these behaviors formally analyzable.

Model based self adaptive behavior language for large scale real time embedded systems

At Fermi lab, high energy physics experiments require very large number of real time computations. With thousands of processors (around /spl sim/1000 FPGAs, /spl sim/2500 embedded processors, /spl sim/2500 PCs and /spl sim/25,000,000 detector channels) involved in performing event filtering on a trigger farm, there is likely to be a large number of failures within the software and hardware systems. Historically, physicists have developed their own software and hardware for experiments such as BTeV [J.N. Buttler (2002)]. However, their time is best spent working on physics and not software development. The target users of this tool are the physicists. The tool should be user-friendly and the physicists should be able to introduce custom self-adaptive behaviors, since they can best define how the system should behave in fault conditions. The BTeV trigger system is being used as a model for researching tools for defining fault behavior and automatically generating the software. This paper presents a language to define the behaviors and an application scenario for the BTeV system and its expected fault scenarios. These self adaptive system tools are implemented using model integrated computing. The domain specific graphical language (DSL) is implemented within the generic modeling environment (GME) tool, which is a meta-programmable modeling environment developed at Vanderbilt University.

ANEMIC: automatic interface enabler for model integrated computing

A domain-specific language provides domain experts with a familiar abstraction for creating computer programs. As more and more domains embrace computers, programmers are tapping into this power by creating their own languages fitting the particular needs of the domain. Graphical domain-specific modeling languages are even more appealing for non-programmers, since the modeling language constructs are automatically transformed into applications through a special compiler called a translator. The Generic Modeling Environment (GME) at Vanderbilt University is a meta-programmable modeling environment. Translators written to interface with GME models typically use a domain-independent API. This paper presents a tool called ANEMIC that generates a domain-specific API for GME translators using the same metamodel that generates the language.

Modeling reflex-healing autonomy for large-scale embedded systems

High-energy physics experiments require an extraordinary amount of real-time computation, and the computers implementing the online data processing must be very reliable because of the large cost associated with operating the facilities and the potential for loss of irreplaceable data. Conventional redundancy-based fault tolerance and adaptive approaches are not appropriate because of the tremendous system cost (fault tolerance is limited to a maximum of 10% overhead). In this work, we developed a framework for building robust embedded systems, which utilizes an autonomic reflex-healing approach to achieve fault tolerance. Components of the framework implement user-defined failure adaptation strategies within the context of a large-scale embedded environment. The tools embrace a model-based approach combining design specification and code-generation for both simulation and system implementation. In this paper we present the concepts and entities of the reflex and healing framework

RTES demo system2004

The RTES Demo System 2004 is a prototype for reliable, fault-adaptive infrastructure applicable to commodity-based dedicated application computer farms, such as the Level 2/3 trigger for the proposed BTeV high energy physics project. This paper describes the prototype, and its demonstration at the 11th IEEE Real Time and Embedded Technology Applications Symposium, RTAS 2005.

The action language: refining a behavioral modeling language

When modeling large-scale complex system behavior we believe there is merit in abandoning the once fashionable all-encompassing system modeling approach in favor of developing a set of models created in a variety of loosely coupled modeling languages. Loosely coupled languages are those that are considered to be nearly orthogonal with respect to their intention, but in reality may display a limited degree of trivial dependencies. We apply this approach toward component behavioral modeling to show how core behaviors of software components can be specified using a statecharts-like behavioral modeling language while elements of the behavior associated with implementation- or platform-specific concepts are modeled using a wholly separate language.

The RTES project - BTeV, and beyond

The real time embedded systems (RTES) project was created to study the design and implementation of high-performance, heterogeneous, and fault-adaptive real time embedded systems. The driving application for this research was the proposed BTeV high energy physics experiment, which called for large farms of embedded computational elements (DSPs), as well as a large farm of conventional high-performance processors to implement its Level 1 and Level 2/3 triggers. At the time of BTeVs termination early in 2005, the RTES project was within days of completing a prototype implementation for providing a reliable and fault-adaptive infrastructure to the L2/3 farm; a prototype for the L1 farm had been completed in 2003. This paper documents the conclusion of the RTES focus on BTeV, and provides an evaluation of the applicability of the RTES concepts to other systems

Dynamically reconfigurable monitoring in large scale real-time embedded systems

This paper presents a tool that enables dynamic reconfigurable monitoring and control in large scale realtime embedded systems and thus fulfils the demands of the users for evolving user interfaces. This is achieved through model based user interfaces. The model based approach provides higher level abstractions, thus allowing the users to configure new user interfaces dynamically without knowing the underlying implementation details. Prototype implementations of software generators have been implemented to directly transform models into target user interfaces. These user interfaces execute under the Matlab runtime environment. This tool, along with other modeling tools developed, provides a framework for achieving fault-tolerance in large-scale distributed real-time embedded systems.