Sumant Tambe

Improving Domain-Specific Language Reuse with Software Product Line Techniques

Complex software systems, such as traffic management systems and shipboard computing environments, raise several concerns (such as performance, reliability, and fault tolerance) that developers must manage throughout the software life cycle. Domain-specific languages (DSLs) have emerged as a powerful mechanism for capturing and reasoning about these diverse concerns. For each system concern, you can design a DSL to precisely capture key domain-level information while shielding developers and users from the technical solutions implementation-level details.

Adaptive Failover for Real-Time Middleware with Passive Replication

Supporting uninterrupted services for distributed soft real-time applications is hard in resource-constrained and dynamic environments, where processor or process failures and system workload changes are common. Fault-tolerant middleware for these applications must achieve high service availability and satisfactory response times for client applications. Although passive replication is a promising fault tolerance strategy for resource-constrained systems, conventional client failover approaches are non-adaptive and load-agnostic, which can cause system overloads and significantly increase response times after failure recovery.This paper presents four contributions to the study of passive replication for distributed soft real-time applications. First, it describes how our Fault-tolerant Load-aware and Adaptive middlewaRe (FLARe) dynamically adjusts failover targets at runtime in response to system load fluctuations and resource availability. Second, it describes how FLARes overload management strategy proactively enforces desired CPU utilization bounds by redirecting clients from overloaded processors. Third, it presents the design and implementation of FLARes lightweight middleware architecture that manages failures and overloads transparently to clients. Finally, it presents experimental results on a distributed Linux testbed that demonstrate how FLARe adaptively maintains soft real-time performance for clients operating in the presence of failures and overloads with negligible runtime overhead.

NetQoPE: A Model-Driven Network QoS Provisioning Engine for Distributed Real-time and Embedded Systems

This paper provides two contributions to the study of quality of service (QoS)-enabled middleware that supports the network QoS requirements of distributed real-time and embedded (DRE) systems. First, we describe the design and implementation of NetQoPE, which is a model-driven component middleware framework that shields applications from the details of network QoS mechanisms by (1) specifying per-flow network QoS requirements, (2) performing resource allocation and validation decisions (such as admission control), and (3) enforcing per-flow network QoS at runtime. Second, we evaluate the effort required and flexibility of using NetQoPE to provide network QoS assurance to end-to-end application flows. Our results demonstrate that NetQoPE can provide network-level differentiated performance to each application flow without modifying its programming model or source code, thereby providing greater flexibility in leveraging network-layer mechanisms.

MDDPro: Model-Driven Dependability Provisioning in Enterprise Distributed Real-Time and Embedded Systems

Service oriented architecture (SOA) design principles are increasingly being adopted to develop distributed real-time and embedded (DRE) systems, such as avionics mission computing, due to the availability of real-time component middleware platforms. Traditional approaches to fault tolerance that rely on replication and recovery of a single server or a single host do not work in this paradigm since the fault management schemes must now account for the timely and simultaneous failover of groups of entities while improving system availability by minimizing the risk of simultaneous failures of replicated entities. This paper describes MDDPro, a model-driven dependability provisioning tool for DRE systems. MDDPro provides intuitive modeling abstractions to specify failover requirements of DRE systems at different granularities. MDDPro enables plugging in different replica placement algorithms to improve system availability. Finally, its generative capabilities automate the deployment and configuration of the DRE system on the underlying platforms.

CQML: Aspect-Oriented Modeling for Modularizing and Weaving QoS Concerns in Component-Based Systems

Current domain-specific modeling (DSM) frameworks for designing component-based systems often consider the systems structural and behavioral concerns as the two dominant concerns of decomposition while treating nonfunctional or quality of service (QoS) concerns as an after thought. Such frameworks lack a strong decoupling between the modeling of the systems structural composition and their QoS requirements. This lack of QoS modularization limits (1) reusability of such frameworks, (2) ease of maintenance when new non-functional characteristics are added, and (3) independent evolution of the modeling frameworks along both the structural and non-functional dimensions. This paper describes Component QoS Modeling Language (CQML), which is a reusable, extensible, and aspect-oriented modeling approach that provides strong separation between the structural and non-functional dimensions. CQML supports independent evolution of structural as well as QoS metamodel of composition modeling languages. The join point model of CQML enables declarative QoS aspect modeling and supports automatic weaving of structural changes effected by QoS requirements. We evaluate the capabilities of CQML for a variety of structural modeling languages and provide quantitative results indicating the modeling effort saved in automating the weaving of QoS concerns.

Reactive stream processing for data-centric publish/subscribe

The Internet of Things (IoT) paradigm has given rise to a new class of applications wherein complex data analytics must be performed in real-time on large volumes of fast-moving and heterogeneous sensor-generated data. Such data streams are often unbounded and must be processed in a distributed and parallel manner to ensure timely processing and delivery to interested subscribers. Dataflow architectures based on event-based design have served well in such applications because events support asynchrony, loose coupling, and helps build resilient, responsive and scalable applications. However, a unified programming model for event processing and distribution that can naturally compose the processing stages in a dataflow while exploiting the inherent parallelism available in the environment and computation is still lacking. To that end, we investigate the benefits of blending Reactive Programming with data distribution frameworks for building distributed, reactive, and high-performance stream-processing applications. Specifically, we present insights from our study integrating and evaluating Microsoft .NET Reactive Extensions (Rx) with OMG Data Distribution Service (DDS), which is a standards-based publish/subscribe middleware suitable for demanding industrial IoT applications. Several key insights from both qualitative and quantitative evaluation of our approach are presented.

Content-based filtering discovery protocol (CFDP): scalable and efficient OMG DDS discovery protocol

The OMG Data Distribution Service (DDS) has been deployed in many mission-critical systems and increasingly in Internet of Things (IoT) applications since it supports a loosely-coupled, data-centric publish/subscribe paradigm with a rich set of quality-of-service (QoS) policies. Effective data communication between publishers and subscribers requires dynamic and reliable discovery of publisher/-subscriber endpoints in the system, which DDS currently supports via a standardized approach called the Simple Discovery Protocol (SDP). For large-scale systems, however, SDP scales poorly since the discovery completion time grows as the number of applications and endpoints increases. To scale to much larger systems, a more efficient discovery protocol is required. This paper makes three contributions to overcoming the current limitations with DDS SDP. First, it describes the Content-based Filtering Discovery Protocol (CFDP), which is our new endpoint discovery mechanism that employs content-based filtering to conserve computing, memory and network resources used in the DDS discovery process. Second, it describes the design of a CFDP prototype implemented in a popular DDS implementation. Third, it analyzes the results of empirical studies conducted in a testbed we developed to evaluate the performance and resource usage of our CFDP approach compared with SDP.

Supporting component-based failover units in middleware for distributed real-time and embedded systems

Although component middleware is increasingly used to develop distributed, real-time and embedded (DRE) systems, it poses new fault-tolerance challenges, such as the need for efficient synchronization of internal component state, failure correlation across groups of components, and configuration of fault-tolerance properties at the component granularity level. This paper makes three contributions to R&D on component-based fault-tolerance. First, it describes the COmponent Replication based on Failover Units (CORFU) component middleware, which provides fail-stop behavior and fault correlation across groups of components treated as an atomic unit in DRE systems. Second, it describes how CORFUs Components with HEterogeneous State Synchronization (CHESS) module provides mechanisms for real-time aware state transfer and synchronization in CORFU. Third, we empirically evaluate the client failover and group shutdown capabilities of CORFU and its CHESS module and compare/contrast it with existing object-oriented fault-tolerance methods. Our results show that component middleware (1) has acceptable fault-tolerance performance for DRE systems, (2) allows timely recovery while considering failure location, size, and functional topology of the group, and finally (3) eases the burden of application development by providing middleware support for fault-tolerance at the component level.

Fault-Tolerance for Component-Based Systems - An Automated Middleware Specialization Approach

General-purpose middleware, by definition, cannot readily support domain-specific semantics without significant manual efforts in specializing the middleware. This paper presents GRAFT (GeneRative Aspects for Fault Tolerance), which is a model-driven, automated, and aspects-based approach for specializing general-purpose middleware with failure handling and recovery semantics imposed by a domain.Model-driven techniques are used to specify the special fault tolerance requirements, which are then transformed into middleware-level code artifacts using generative programming. Since the resulting fault tolerance semantics often crosscut the middleware architecture, GRAFT uses aspect-oriented programming to weave them into the original fabric of the general-purpose middleware. We evaluate the capabilities of GRAFT using a representative case study.

Towards a QoS Modeling and Modularization Framework for Component-based Systems

Current domain-specific modeling (DSM) frameworks for designing component-based systems provide modeling support for systems structural as well as non-functional or quality of service (QoS) concerns. However, the focus of such frameworks on systems non-functional concerns is an after-thought and their support is at best adhoc. Further, such frameworks lack strong decoupling between the modeling of the systems structural composition and their QoS requirements. This lack of QoS modularization limits (1) reusability of such frameworks, (2) ease of their maintenance when new non-functional characteristics are added, and (3) independent evolution of the modeling frameworks along both the structural and non-functional dimensions. This paper describes Component QoS modeling language (CQML), which is a reusable, extensible, and platform-independent QoS Modeling Language that provides strong separation between the structural and non-functional dimensions. CQML supports independent evolution of structural metamodel of composition modeling languages as well as QoS metamodel. To evaluate, we superimpose CQML on a purely structural modeling language and automatically generate, configure, and deploy componentbased fault-monitoring infrastructure using aspect-oriented modeling (AOM) techniques.