SCIRun2:A CCA Framework for High Performance Computing
Kostadin Damevski2004, Ninth International Workshop on High-Level Parallel Programming Models and Supportive Environments, 2004. Proceedings.
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
We present an overview of the SCIRun2 parallel component framework. SCIRun2 is based on the Common Component Architecture (CCA) and the SCI Institutes' SCIRun[10]. SCIRun2 supports distributed computing through distributed objects. Parallel components are managed transparently over an MxN method invocation and data redistribution subsystem. A meta component model based on CCA is used to accommodate multiple component models such as CCA, CORBA and Dataflow. A group of monitoring components built on top of the TAU toolkit[13] evaluate the performance of the other components.
Related papers
Highly Scalable Distributed Component Framework for Scientific Computing
As scientific computing experiences continuous growth of the size of simulations, component frameworks intended for scientific computing need to handle more components and execute on numerous hardware resources simultaneously. Our distributed component framework CCALoop presents a novel design that supports scalability in both number of components in the system and distributed computing resources. CCALoop also presents several other beneficial design principles for distributed component frameworks such as fault-tolerance, parallel components, and support for multiple users. To provide scalability it distributes the responsibility for data queries and updates equally to all nodes in the system through a distributed hash table mechanism, while providing low latency in these operation through a method that guarantees one-hop routing of framework messages.
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.
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.
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
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.
A case study on expressiveness and performance of component-oriented parallel programming
2013
Component-oriented programming has been applied to address the requirements of large-scale applications from computational sciences and engineering that present high performance computing (HPC) requirements. However, parallelism continues to be a challenging requirement in the design of CBHPC (Component-Based High Performance Computing) platforms. This paper presents strong evidence about the efficacy and the efficiency of HPE (Hash Programming Environment), a CBHPC platform that provides full support for parallel programming, on the development, deployment and execution of numerical simulation code onto cluster computing platforms.
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.
On the viability of component frameworks for high performance distributed computing: a case study
Proceedings 11th IEEE International Symposium on High Performance Distributed Computing
Software infrastructures that support metacomputing are evolving from traditional monolithic, platform-specific systems to component and service-based frameworks. In this paper we demonstrate that contrary to popular belief, such modular software systems are capable of delivering good to excellent performance, support legacy as well as new application programming paradigms, and deliver enhanced functionality. The Harness system, a software backplane enabling reconfigurable distributed concurrent computing is used to emulate the PVM programming environment. Numerical kernel benchmarks show that application performance results using the emulator and native versions are within a few percent of each other. Coupled with the ability to leverage pre-existing and specialized modules, our experiences suggest that service-oriented computational grids may be constructed rapidly and effectively via such component-based architectural frameworks that deliver full functionality without compromising efficiency.
A High Performance Computing Platform for Component-Based Parallel Programming
sbc.org.br
Component-based programming has been applied to address the requirements of High Performance Computing (HPC) applications. Due the poor support of parallelism on current infrastructures, the # component model and its based framework for parallel applications have been proposed, motivating the development of component based environments for parallel programming targeting high-end computing architecture.
Achieving portable and efficient parallel CORBA objects
Concurrency and Computation: Practice and Experience, 2003
With the availability of Computational Grids, new kinds of applications are emerging. They raise the problem of how to program them on such computing systems. In this paper, we advocate a programming model based on a combination of parallel and distributed programming models. Compared to previous approaches, this work aims at bringing single program multiple data (SPMD) programming into CORBA in a portable way. For example, we want to interconnect two parallel codes by CORBA without modifying either CORBA or the parallel communication API. We show that such an approach does not entail any loss of performance compared to previous approaches that required modification to the CORBA standard. Moreover, using an ORB that is able to exploit high-performance networks, we show that portable parallel CORBA objects can efficiently make use of such networks. Copyright © 2003 John Wiley & Sons, Ltd.
Related topics
Related papers
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,
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.
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.
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.
POET (Parallel Object-Oriented Environment and Toolkit) and frameworks for scientific distributed computing
Proceedings of the Thirtieth Hawaii International Conference on System Sciences
O S T ' Frameworks for parallel computing have recently become popular as a means for preserving parallel algorithms as reusable components. Frameworks for parallel computing in general, and POET in particular, focus on finding ways to orchestrate and facilitate cooperation between components that implement the parallel algorithms. Since performance is a key requirement for POET applications, CORBA or CORBA-like systems are eschewed for a SPMD message-passing architecture common to the world of distributed-parallel computing. Though the system is written in C++ for portability, the behavior of POET is more like a classical framework, such as Smalltalk. POET seeks to be a general platform for scientific parallel algorithm components which can be modified, linked, "mixed and matched" to a user's specification. The purpose of this work is to identify a means for parallel code reuse and to make parallel computing more accessible to scientists whose expertise is outside the field of parallel computing. The POET framework provides two things: 1) an object model for parallel components that allows cooperation without being restrictive; 2) services that allow components to access and manage user data and message-passing facilities, etc. This work has evolved through application of a series of "real" distributed-parallel scientific problems. The paper focuses on what is required for parallel components to cooperate and at the same time remain "black-boxes" that users can drop into the frame without having to know the exquisite details of message-passing, data layout, etc. The paper walks through a specific example of a chemically reacting flow application. The example is implemented in POET and we identify component cooperation, usability and reusability in an anecdotal fashion. The following conclusions are drawn: 1) Specifically, POET components not only execute their assigned tasks, but provide data dependency information allowing components to cooperate on data decomposed across distributed machines. cu , This report was prepared as an account of work sponsored by an agency of the United States Government.
A Platform of Components for Large Scale Parallel Programming
Component-based programming has been applied to address the requirements of large scale applications from sciences and engineering, with high performance computing requirements. However, parallelism has been poorly supported in usual component infrastructures. This paper presents the design and implementation of a parallel components platform based on the HASH component model, targeting clusters and well suited for programming-in-the-large.
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
The SCIJump Framework for Parallel and Distributed Scientific Computing
Advanced Computational Infrastructures for Parallel and Distributed Adaptive Applications, 2009
THEMIS: COMPONENT DEPENDENCE METADATA IN ADAPTIVE PARALLEL APPLICATIONS
Parallel Processing Letters, 2001
There is a conflict between the goals of improving the quality of scientific software and improving its performance. A key issue is to support reuse and re-assembly of sophisticated software components without compromising performance. This paper describes THEMIS, a programming model and run time library being designed to support cross-component performance optimisation through explicit manipulation of the computation's iteration space at run-time.
CORBA Lightweight Components: A Model for Distributed Component-Based Heterogeneous Computation
Lecture Notes in Computer Science, 2001
In this article we present CORBA Lightweight Components, CORBA-LC, a new network-centered reflective component model which allows building distributed applications assembling binary independent components spread on the network. It provides a peer network view in which the component dependencies are managed automatically to perform an intelligent application run-time deployment, leading to better utilization of resources. We show the validity of the CORBA-LC approach in dealing with CSCW and Grid Computing applications.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.