Software Architecture Issues in Scientific Component Development
Boyana Norris2006, Lecture Notes in Computer Science
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
Commercial component-based software engineering practices, such as the CORBA component model, Enterprise JavaBeans, and COM, are well-established in the business computing community. These practices present an approach for managing the increasing complexity of scientific software development, which has motivated the Common Component Architecture (CCA), a component specification targeted at highperformance scientific application development. The CCA is an approach to component development that is minimal in terms of the complexity of component interface requirements and imposes a minimal performance penalty. While this lightweight specification has enabled the development of a number of high-performance scientific components in several domains, the software design process for developing component-based scientific codes is not yet well defined. This fact, coupled with the fact that component-based approaches are still new to the scientific community, may lead to an ad hoc design process, potentially resulting in code that is harder to maintain, extend, and test and may negatively affect performance. We explore some concepts and approaches based on widely accepted software architecture design principles and discuss their potential application in the development of high-performance scientific component applications. We particularly emphasize those principles and approaches that contribute to making CCA-based applications easier to design, implement, and maintain, as well as enabling dynamic adaptivity with the goal of maximizing performance.
Related papers
Managing complexity in modern high end scientific computing through component-based software engineering
The ever-increasing complexity of modern high-performance scientific simulation software presents a tremendous challenge to the development and use of this type of software, with significant impacts on productivity. Component-based software engineering is a means of addressing complexity that has been developed primarily in response to the needs of business and related software environments, but which has not yet had a significant impact on high-end computing. In this paper, we present the Common Component Architecture (CCA) as a com-ponent model designed to meet the special needs of high-performance scientific computing, focusing on how the CCA addresses issues of complexity. Unique among component architectures is the technique presented here by which a CCA component can act as a container to encapsulate and control other components without itself having to implement the functionality of a framework.
COMODI: Architecture for a Component-Based Scientific Computing System
Computing Research Repository, 2005
The COmputational MODule Integrator (COMODI) [1] is an initiative aiming at a component based framework, component developer tool and component repository for scientific computing. We identify the main ingredients to a solution that would be sufficiently appealing to scientists and engineers to consider alternatives to their deeply rooted programming traditions. The overall structure of the complete solution is sketched with special emphasis on the Component Developer Tool standing at the basis of COMODI.
A high performance software component architectures for SciTL. Final report
2001
The idea of using component frameworks to deal with the complexity of developing interdisciplinary HPC applications is becoming increasingly popular. Such systems enable programmers to accelerate project development through introducing higher level abstractions and allowing code reusability, as well as provide clearly specified component interfaces which facilitate the task of team interaction. These potential benefits has encouraged research groups within a number of laboratories and universities to develop, and experiment with prototype systems. Consequently, there is a need for an interoperablity standard. The need for component programming has been recognized by the business world and resulted in the development of systems such as Microsoft COM, the new Corba Component Model (CCM), Enterprise Java Beans and others. However, these systems were designed primarily for sequential applications and do not address the needs of HPC. Their most important shortcoming from the point of view of HPC is that they don't support abstractions necessary for high-performance, parallel programming, and don't stress enough what is often the most important factor in scientific programming: performance. In addition, the existing systems are often invasive, that is, they require substantial modifications to existing applications which may not be acceptable to the developer of high-performance components. In view of these problems it is critical to develop a standard which will address specifically the needs of HPC community. To this end, we embarked a collaboration with
Component Based Programming in Scientific Computing: A Practical Approach/the Viable Approach
Computational scientists are facing a new era where the old ways of developing and reusing code have to be left behind and a few daring steps are to be made towards new horizons. The present work analyzes the needs that drive this change, the factors that contribute to the inertia of the community and slow the transition, the status and perspective of present attempts, the principle, practical and technical problems that are to be addressed in the short and long run.
A Component Architecture for High-Performance Scientific Computing
International Journal of High Performance Computing Applications, 2006
The Common Component Architecture (CCA) provides a means for software developers to manage the complexity of large-scale scientific simulations and to move toward a plug-and-play environment for high-performance computing. In the scientific computing context, component models also promote collaboration using independently developed software, thereby allowing particular individuals or groups to focus on the aspects of greatest interest to them. The CCA supports parallel and distributed computing as well as local high-performance connections between components in a language-independent manner. The design places minimal requirements on components and thus facilitates the integration of existing code into the CCA environment. The CCA model imposes minimal overhead to minimize the impact on application performance. The focus on high performance distinguishes the CCA from most other component models. The CCA is being applied within an increasing range of disciplines, including combustion research, global climate simulation, and computational chemistry.
An XML Based Component Model for Generating Scientific Applications and Performing Large Scale Simulations In a Meta-Computing Environment
Generative and Component-Based …, 2000
Research initiatives for plug-and-play scientific computing
Journal of Physics: Conference Series, 2007
This paper introduces three component technology initiatives within the SciDAC Center for Technology for Advanced Scientific Component Software (TASCS) that address everincreasing productivity challenges in creating, managing, and applying simulation software to scientific discovery. By leveraging the Common Component Architecture (CCA), a new component standard for high-performance scientific computing, these initiatives tackle difficulties at different but related levels in the development of component-based scientific software: (1) deploying applications on massively parallel and heterogeneous architectures, (2) investigating new approaches to the runtime enforcement of behavioral semantics, and (3) developing tools to facilitate dynamic composition, substitution, and reconfiguration of component implementations and parameters, so that application scientists can explore tradeoffs among factors such as accuracy, reliability, and performance.
A JAVA application framework for scientific software development
Software: Practice and Experience, 2012
This paper presents AIBench, a Java desktop application framework mainly focused on scientific software development, with the goal of improving the productivity of research groups. Following the MVC design pattern, the programmer is able to develop applications using only three types of concepts: operations, data-types and views. The framework provides the rest of the functionality present in typical scientific applications, including user parameter requests, logging facilities, multi-threading execution, experiment repeatability and graphic user interface generation, among others. The proposed framework is implemented following a plugin-based architecture which also allows assembling new applications by the reuse of modules from past development projects.
Scientific Workflows and Components: Together at Last!
2008
Composing scientific simulations from smaller general pieces has many beneficial properties such as modularity and reuse. Component software and scientific workflows are both technologies for decomposition of scientific simulation, although each of them performs this task along a separate dimension and on a different level. Scientific workflows are concerned with high-level orchestration of a time-decomposed simulation, while components are mainly used at a lower level to enable software modularity and reuse at a small performance cost. Combining these technologies in a seamless way leaverages the benefits of both decomposition paradigms, resulting in more flexibility for scientific application design. In this work, we describe a system that communicates parameters and results to and from a Common Component Architecture (CCA) framework and the Kepler scientific workflow system.
Guest editorial to the Special Issue on Component-Based Software Engineering and Software Architecture
Science of Computer Programming, 2014
Related papers
Lessons Learned from Using CORBA for Components in Scientific Computing
2000
The use of component architectures to solve the problem of reuse and interoperability in scientific computing has been investigated by various research groups during the last years. Moreover, architectures for Internet accessible math- ematical services have been proposed. In this paper give a brief abstract require- ments analysis with respect to these problems and show that there is an existing
Component Based Programming in Scientific Computing: The Viable Approach
2005
Computational scientists are facing a new era where the old ways of developing and reusing code have to be left behind and a few daring steps are to be made towards new horizons. The present work analyzes the needs that drive this change, the factors that contribute to the inertia of the community and slow the transition, the status and perspective of present attempts, the principle, practical and technical problems that are to be addressed in the short and long run.
Component-based software for high-performance scientific computing
Journal of Physics: Conference Series, 2005
Recent advances in both computational hardware and multidisciplinary science have given rise to an unprecedented level of complexity in scientific simulation software. This paper describes an ongoing grass roots effort aimed at addressing complexity in high-performance computing through the use of Component-Based Software Engineering (CBSE). Highlights of the benefits and accomplishments of the Common Component Architecture (CCA) Forum and SciDAC ISIC are given, followed by an illustrative example of how the CCA has been applied to drive scientific discovery in quantum chemistry. Thrusts for future research are also described briefly.
A performance interface for component-based applications
Proceedings International Parallel and Distributed Processing Symposium, 2003
This work targets the emerging use of software component technology for high-performance scientific parallel and distributed computing. While component software engineering will benefit the construction of complex science applications,
An Aspect Oriented Framework for Scientific Component Development
2005
Aspect-Oriented Programming enables developers to capture in separated aspect modules concerns that are spread over different components in a system. This paper is an attempt to apply this paradigm to High Performance Computing. Besides achieving the usual advantages of improved modularity, more reusable code that is easier to develop and maintain, we pursue to improve efficiency by means of dynamic changes of aspects at runtime.
Enabling self-management of component-based high-performance scientific applications
2005
gorizes. operational requiremenrs of scient@ applications, and allows rhem io be speciJied and enforced ut runrime through re-configuration, optimization and healing of individual components and rhe application. Two scient@ simulations are used to illustrate the system and its selfmanaging behaviors. A perJomance evaluation is also pwsented.
The CCA component model for high-performance scientific computing
Concurrency and Computation: Practice and Experience, 2006
The Common Component Architecture (CCA) is a component model for high-performance computing, developed by a grass-roots effort of computational scientists. Although the CCA is usable with CORBA-like distributed-object components, its main purpose is to set forth a component model for high-performance, parallel computing. Traditional component models are not well suited for performance and massive parallelism. We outline the design pattern for the CCA component model, discuss our strategy for language interoperability, describe the development tools we provide, and walk through an illustrative example using these tools. Performance and scalability, which are distinguishing features of CCA components, affect choices throughout design and implementation.
Managing Scientific Software Complexity with Bocca and CCA
Scientific Programming, 2008
In high-performance scientific software development, the emphasis is often on short time to first solution. Even when the development of new components mostly reuses existing components or libraries and only small amounts of new code must be created, dealing with the component glue code and software build processes to obtain complete applications is still tedious and error-prone. Component-based software meant to reduce complexity at the application level increases complexity to the extent that the user must learn and remember the interfaces and conventions of the component model itself. To address these needs, we introduce Bocca, the first tool to enable application developers to perform rapid component prototyping while maintaining robust software-engineering practices suitable to HPC environments. Bocca provides project management and a comprehensive build environment for creating and managing applications composed of Common Component Architecture components. Of critical importance for high-performance computing (HPC) applications, Bocca is designed to operate in a language-agnostic way, simultaneously handling components written in any of the languages commonly used in scientific applications: C, C++, Fortran, Python and Java. Bocca automates the tasks related to the component glue code, freeing the user to focus on the scientific aspects of the application. Bocca embraces the philosophy pioneered by Ruby on Rails for web applications: start with something that works, and evolve it to the user's purpose.
Improvements in the efficient composition of applications built using a component-based programming environment
18th International Parallel and Distributed Processing Symposium, 2004. Proceedings., 2004
Performance technology for parallel and distributed component software
Concurrency and Computation: Practice and Experience, 2005
issues in high-performance component environments. We describe a prototype implementation of a performance measurement infrastructure for the Common Component Architecture (CCA) system. A case study demonstrating the use of this technology for integrated measurement, monitoring, and optimization in CCA component-based applications is given.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.