Chiyoung Seo

An energy consumption framework for distributed java-based systems

In this paper we define and evaluate a framework for estimating the energy consumption of Java-based software systems. Our primary objective in devising the framework is to enable an engineer to make informed decisions when adapting a systems architecture, such that the energy consumption on hardware devices with a finite battery life is reduced, and the lifetime of the systems key software services increases. Our framework explicitly takes a component-based perspective, which renders it well suited for a large class of todays distributed, embedded, and pervasive applications. The framework allows the engineer to estimate the software systems energy consumption at system construction-time and refine it at runtime. In a large number of distributed application scenarios, the framework showed very good precision on the whole, giving results that were within 5% (and often less) of the actually measured power losses incurred by executing the software. Our work to date has also highlighted a number of possible enhancements

Component-Level Energy Consumption Estimation for Distributed Java-Based Software Systems

Efficiency with respect to energy consumption has increasingly been recognized as an important quality attribute for distributed software systems in embedded and pervasive environments. In this paper we present a framework for estimating the energy consumption of distributed software systems implemented in Java. Our primary objective in devising the framework is to enable an engineer to make informed decisions when adapting a systems architecture, such that the energy consumption on hardware devices with a finite battery life is reduced, and the lifetime of the systems key software services increases. Our framework explic itly takes a component-based perspective, which renders it well suited for a large class of todays distributed, embedded, and pervasive applications. The framework allows the engineer to estimate the distributed systems energy consumption at sys tem construction-time and refine it at runtime. In a large number of distributed application scenarios, the framework showed very good precision on the whole, giving results that were within 5% (and often less) of the actual energy consump tion incurred by executing the software. Our work to date has also highlighted the frameworks practical applications and a number of possible enhancements.

Reconceptualizing a Family of Heterogeneous Embedded Systems via Explicit Architectural Support

It has been widely advocated that software architecture provides an effective set of abstractions for engineering (families of) complex software systems. However, architectural concepts are seldom supported directly at the level of system implementation. In embedded environments in particular, developers are often forced to rely on low-level programming languages. While this is conducive to fine-grain control over the system, it does not lend itself to addressing larger issues such as ensuring architectural integrity or managing an application family. In this paper we describe our experience with fundamentally altering the manner in which a family of embedded applications is designed, analyzed, implemented, deployed, and evolved using explicit architectural constructs. We discuss our strategy, the challenges we faced in the course of our project, the lessons learned in the process, and several open issues that remain unresolved.

An efficient inverted index technique for XML documents using RDBMS

Abstract The inverted index is widely used in the existing information retrieval field. In order to support containment queries for structured documents such as XML, it needs to be extended. Previous work suggested an extension in storing the inverted index for XML documents and processing containment queries, and compared two implementation options: using an RDBMS and using an Information Retrieval (IR) engine. However, the previous work has two drawbacks in extending the inverted index. One is that the RDBMS implementation is generally much worse in the performance than the IR engine implementation. The other is that when a containment query is processed in an RDBMS, the number of join operations increases in proportion to the number of containment relationships in the query and a join operation always occurs between large relations. In order to solve these problems, we propose in this paper a novel approach to extend the inverted index for containment query processing, and show its effectiveness through experimental results. In particular, our performance study shows that (1) our RDBMS approach almost always outperforms the previous RDBMS and IR approaches, (2) our RDBMS approach is not far behind our IR approach with respect to performance, and (3) our approach is scalable to the number of containment relationships in queries. Therefore, our results suggest that, without having to make any modifications on the RDBMS engine, a native implementation using an RDBMS can support containment queries as efficiently as an IR implementation.

Estimating the Energy Consumption in Pervasive Java-Based Systems

We define and evaluate a framework for estimating the energy consumption of pervasive Java-based software systems. The frameworks primary objective is to enable an engineer to make informed decisions when adapting a systems architecture, such that the energy consumption on hardware devices with a finite battery life is reduced, and the lifetime of the systems key software services increases. Our framework explicitly takes a component-based perspective, which renders it well suited for a large class of todays distributed, embedded, and pervasive applications. The framework provides a novel approach that facilitates the accurate estimation of a systems energy consumption both during system construction-time and during runtime. In a large number of distributed application scenarios, the framework showed very good precision on the whole, giving results that were within 5% of the actually measured power losses incurred by executing the software.

A framework for estimating the energy consumption induced by a distributed system's architectural style

The architectural style used in a software system is an important factor in satisfying its quality requirements. In battery-powered environments, such as mobile and pervasive systems, efficiency with respect to energy consumption is often an important quality requirement. In this paper, we present a framework that facilitates early estimation of the energy consumption induced by an architectural style in a distributed system, and enables an engineer to use energy consumption estimates along with other quality attributes in determining the most appropriate style for a given distributed application. We apply the framework to three architectural styles, and evaluate it for precision and accuracy using a middleware platform that supports the implementation of those styles. In a large number of application scenarios, our framework exhibited excellent precision, in that it was consistently able to correctly rank the styles and estimate the relative differences in their energy costs. Moreover, the framework has also proven to be accurate: its estimates were within 7% of each style implementations actual energy cost.

Exploring the Role of Software Architecture in Dynamic and Fault Tolerant Pervasive Systems

Pervasive systems are rapidly growing in size, complexity, distribution, and heterogeneity. As a result, the traditional practice of developing one-off embedded applications that are often rigid and unmanageable is no longer acceptable. This is particularly evident in a growing class of mobile and dynamic pervasive systems that are highly unpredictable, and thus require flexible and adaptable software support. At the same time, many of these applications are mission critical and have stringent fault tolerance requirements. In this paper, we argue that an effective approach to developing software systems in this domain is to employ the principles of software architecture. We discuss the design and implementation of facilities we have provided in a tool-suite targeted for architecture-based development of fault tolerant pervasive systems.

SHARE Interface in Flash Storage for Relational and NoSQL Databases

Database consistency and recoverability require guaranteeing write atomicity for one or more pages. However, contemporary database systems consider write operations non-atomic. Thus, many database storage engines have traditionally relied on either journaling or copy-on-write approaches for atomic propagation of updated pages to the storage. This reliance achieves write atomicity at the cost of various write amplifications such as redundant writes, tree-wandering, and compaction. This write amplification results in reduced performance and, for flash storage, accelerates device wear-out. In this paper, we propose a flash storage interface, SHARE. Being able to explicitly remap the address mapping inside flash storage using SHARE interface enables host-side database storage engines to achieve write atomicity without causing write amplification. We have implemented SHARE on a real SSD board, OpenSSD, and modified MySQL/InnoDB and Couchbase NoSQL storage engines to make them compatible with the extended SHARE interface. Our experimental results show that this SHARE-based MySQL/InnoDB and Couchbase configurations can significantly boost database performance. In particular, the inevitable and costly Couchbase compaction process can complete without copying any data pages.

Self-* software architectures and component middleware in pervasive environments

Software systems that execute in embedded and pervasive environments are frequently required to be self-monitoring, self-adapting, and self-healing. However, supporting these self-* capabilities in pervasive environments creates a number of unique engineering challenges. This paper first describes the challenges that we believe to be the most significant based on our experience developing real-world pervasive software applications with self-* capabilities. We then discuss each challenge in the context of four strategies commonly employed in self-* systems: dynamic software update, service discovery, transparent replication, and logical mobility. Finally, we explain how each strategy is implemented in our architectural middleware platform, Prism-MW.

Tailoring an architectural middleware platform to a heterogeneous embedded environment

Embedded systems are rapidly growing in size, complexity, distribution, and heterogeneity. As a result, the traditional practice of developing one-off embedded applications that are often rigid and unmanageable is no longer acceptable. Recent studies have suggested that an effective approach to developing software systems in this domain is to employ the principles of software architecture. However, for software architectural concepts to be truly useful in a development setting, they must be accompanied by support for their implementation and evolution. This has motivated our work over the past several years on an architectural middleware, called Prism-MW, that provides implementation-level support for the development of software systems in terms of the software architectural constructs (e.g., components, connectors). Prism-MW was initially developed in Java and used in several domains. Recently, as part of an on-going project, we were required to implement Prism-MW in ANSI C++. This experience proved to be more challenging than we initially anticipated, mainly due to the inherent heterogeneity of the computing substrate. As a result of this experience, we had to reconsider some of our earlier assumptions of what constitutes an architectural middleware and its role in the software development process. In this paper, we provide an overview of our experience and the lessons we have learned along the way.