Chitra Babu

A novel indexing scheme for efficient handling of small files in Hadoop Distributed File System

Hadoop Distributed File System (HDFS) is designed for reliable storage and management of very large files. All the files in HDFS are managed by a single server, the NameNode. NameNode stores metadata, in its main memory, for each file stored into HDFS. As a consequence, HDFS suffers a performance penalty with increased number of small files. Storing and managing a large number of small files imposes a heavy burden on the NameNode. The number of files that can be stored into HDFS is constrained by the size of NameNodes main memory. Further, HDFS does not take the correlation among files into account, and it does not provide any prefetching mechanism to improve the I/O performance. In order to improve the efficiency of storing and accessing the small files on HDFS, we propose a solution based on the works of Dong et al., namely Extended Hadoop Distributed File System (EHDFS). In this approach, a set of correlated files is combined, as identified by the client, into a single large file to reduce the file count. An indexing mechanism has been built to access the individual files from the corresponding combined file. Further, index prefetching is also provided to improve I/O performance and minimize the load on NameNode. The experimental results indicate that EHDFS is able to reduce the metadata footprint on NameNodes main memory by 16% and also improve the efficiency of storing and accessing large number of small files.

Fault model and test-case generation for the composition of aspects

Aspect-Oriented Programming (AOP) is an emerging paradigm that enhances the modularity of Object-Oriented Programming (OOP) by eliminating tangling and scattering in the code. The scattering code is encapsulated within a module called an Aspect. A join point is an execution point in a program. When there is more than one aspect sharing the same join point then it becomes necessary to identify the faults that occur during their composition. A Fault model is instrumental in identifying the faults that can occur in any software system. Research works so far have focused on the composition of Aspects only from the implementation standpoint. It is necessary to identify these faults during the design process, early in the software development lifecycle. This would help in adopting better coding strategies that result in modular, reusable and maintainable code. Towards this objective, this paper proposes a candidate fault model that identifies the faults which occur during Aspect Composition from the design. Use-case scenarios and sequence diagrams are used to reflect the design of the system. The proposed fault model identifies the faults from the sequence diagrams. Test cases are generated from the design using black-box testing strategy. The proposed fault model is also applied to an illustrative case study and has been validated using test case coverage analysis.

Performance Prediction Model for Service Oriented Applications

Software architecture plays a significant role in determining the quality of a software system. It exposes important system properties for consideration and analysis. Performance related properties are frequently of interest in determining the acceptability of a given software design. This paper focuses mainly on developing an architectural model for applications that use service oriented architecture (SOA). This enables predicting the performance of the application even before it is completely developed. The performance characteristics of the components and connectors are modeled using queuing network model. This approach facilitates the performance prediction of service oriented applications. Further, it also helps in identification of various bottlenecks. A prototype service oriented application has been implemented and the actual performance is measured. This is compared against the predicted performance in order to analyze the accuracy of the prediction.

Template based SOA framework for dynamic and adaptive composition of web services

Automated Web service composition is currently one of the major research problems in the area of service oriented computing. Web services facilitate seamless business-to-business integration. Whenever it becomes difficult to find a single service for a particular task, a composition of services that can together perform the given task, is required. In general, this is accomplished using Service Oriented Architecture (SOA). However, the requirements of the users are frozen before the system locates, composes and executes the required services. The response is not personalized to the user environment. Further, conventional web services cannot handle the context and the context aware web services need to contain the context processing logic. Hence, we propose a framework for dynamic composition of Web services using templates in SOA. This framework allows maximum flexibility for the users to change their requirements at runtime and provides adaptive composition irrespective of whether a web service is context enabled or not.

A load balancing algorithm for private cloud storage

Cloud computing enables on-demand network access to a shared pool of configurable computing resources such as servers, storage and applications. These shared resources can be rapidly provisioned to the consumers on the basis of paying only for whatever they use. Cloud storage refers to the delivery of storage resources to the consumers over the Internet. Private cloud storage is restricted to a particular organization and data security risks are less compared to the public cloud storage. Hence, private cloud storage is built by exploiting the commodity machines within the organization and the important data is stored in it. When the utilization of such private cloud storage increases, there will be an increase in the storage demand. It leads to the expansion of the cloud storage with additional storage nodes. During such expansion, storage nodes in the cloud storage need to be balanced in terms of load. In order to maintain the load across several storage nodes, the data need to be migrated across the storage nodes. This data migration consumes more network bandwidth. The key idea behind this paper is to develop a dynamic load balancing algorithm to balance the load across the storage nodes during the expansion of private cloud storage.

Effective self adaptation by integrating adaptive framework with architectural patterns

As software development becomes large-scale, the major focus of the developers has shifted from algorithms and data structures to architectures of the software systems. Architecture provides a bridge between requirements and implementation. Until recently, mechanism for self adaptation is largely in the form of programming language features embedded in code, thus prohibiting reusability and modifiability. This paper advocates the use of an external mechanism which monitors the running system and updates the architectural properties based on the changes in the system. Haphazard changes made in the architecture might make the system unstable. In order to address this issue, this paper proposes an approach for dynamic self adaptation by integrating the adaptive framework with architectural patterns. Since the architectural patterns have some predefined and proven structure, they make the system amenable for easy adoption. The changes in the architecture are mapped back to the running system. The external mechanism thus monitors and makes changes to the running system dynamically. The proposed approach has been tested by applying it to a sample e-Shopping application case study.

Metrics-based design selection tool for aspect oriented software development

Software metrics provide a means for software practitioners to assess the quality of their software. Ideally, this information should be available earlier in the software development lifecycle, since changes are much more expensive to incorporate in the later stages. Design level metrics offer an elegant way of capturing this information. Research in software design metrics has focused primarily on procedural and object oriented software. However, such metrics are currently not available for Aspect Oriented Software Development (AOSD), which is an emerging paradigm. Aspect Oriented Programming (AOP) is an approach that allows programmers to modularize crosscutting concerns that are scattered across multiple modules. Separation of concerns through aspects has the advantages of increased reliability, adaptability and better reuse. The objective of this paper is to propose suitable metrics for the Aspect Oriented Design (AOD) and to develop a tool that will automatically select a better design based on the proposed metrics. In this paper, class and sequence diagrams are used to represent an AOD. The proposed design level metrics are applied to two alternative designs of an illustrative case study. The tool selects the design that better suits stakeholder requirements, based on logical inferences obtained from these metrics regarding the quality of the Aspect Oriented software.

Deriving reliable compositions using cancelable web services

Reliability is one of the main challenges while composing web services. Due to the inherent heterogeneity of web services, it is important to predict the behaviour of the overall composite service. Existing works that deal with reliable web service composition consider only three basic transactional properties such as pivot, retriable, and compensatable. When a service fails, its results can be ignored if it is pivot; it can be retried until it succeeds if it is retriable; or the previously completed services must be rolled back if they are compensatable, in order to achieve reliable execution. In general, business applications involve long running services. Service execution must be interrupted to adapt to dynamically changing user preferences since execution of the service to completion with the older requirements is no longer meaningful. Hence, service composition requires additional transactional support beyond the three transactional properties. To address this need, we introduce cancelable services and investigate the transactional properties of composite services that involve cancelable component services. The valid compositions, which result in a reliable execution are identified and formally verified.

Design level metrics to measure the complexity across versions of AO software

Software metric plays a vital role in quantitative assessment of any specific software development methodology and its impact on the maintenance of software. It can also be used to indicate the degree of interdependence among the components by providing valuable feedback about quality attributes such as maintainability, modifiability and understandability. The effort for software maintenance normally has a high correlation with the complexity of its design. Aspect Oriented Software Design is an emerging methodology that provides powerful new techniques to improve the modularity of software from its design. In this paper, evaluation model to capture the symptoms of complexity has been defined consisting of metrics, artifacts and elements of complexity. A tool to automatically capture these metrics across different versions of a case study application, University Automation System has been developed. The values obtained for the proposed metrics are used to infer on the complexity of Java and AspectJ implementations of the case study application. These measurements indicate that AspectJ implementations are less complex compared to the Java implementations and there by positively influencing the maintainability of software.

Evaluation of reusability in Aspect Oriented Software using inheritance metrics

Aspect-Oriented Software Development (AOSD) is a promising methodology for efficiently capturing the cross-cutting functionalities (concerns) as independent units called aspects. Inheritance of classes and aspects play a vital role in defining the units of encapsulation. Hence, it is essential to quantitatively capture the impact of inheritance in AOSD using design level metrics and to infer on the higher level quality attribute, reusability. An application to automate the processes of a typical University has been developed in order to study the effect of using inheritance over the versions of an aspectized AO application. A set of metrics to capture the manifestations of inheritance is proposed for measurement. An automated tool named as Aspect Oriented Software Reusability Measurement AOSRM is also designed and developed to calculate the values of the proposed metrics. Based on the obtained metric values for Java and AspectJ versions of the case study application, inheritance in AspectJ versions showed a positive impact on reusability of software.