Tool Support for Component-Based Software Architectures

2009 ◽  
Author(s):  
Georg Buchgeher ◽  
Rainer Weinreich
Keyword(s):  
Tool Support ◽  
Software Architectures

A Specification and Detection Approach for Parallel Evolution Conflicts of Software Architectures

2017 ◽  
Vol 27 (03) ◽  
pp. 373-398 ◽  
Author(s):  
Hongzhen Xu ◽  
Wenlin Song ◽  
Zhiqiang Liu
Keyword(s):  
Software Development ◽  
Software Architecture ◽  
Software Evolution ◽  
Parallel Evolution ◽  
Critical Pair ◽  
Tool Support ◽  
Software Architectures ◽  
Detection Approach ◽  
Architecture Evolution ◽  
Definition Of

Software evolution has been a necessary part of the software development, while software architecture evolution is an important issue of software evolution. Software architecture evolution is generally realized through some evolution operations such as adding components or connectors, removing components or connectors. However, when some evolution operations are applied to the same software architecture in parallel, they sometimes make conflicting modifications, which will hinder the correctness of software architecture evolution. Although different approaches have been proposed to describe and analyze software architecture evolution, little work has been made to address evolution conflicts of software architectures. Focusing on parallel evolution conflicts of software architectures, firstly the paper establishes definitions and characterizations of parallel evolution conflicts of software architectures based on hypergraph morphisms and set theories, and describes parallel evolution conflicts of software architectures through these definitions and characterizations. Secondly the paper constructs the critical pair definition of parallel evolution conflicts of software architectures based on hypergraphs and hypergraph morphisms, analyzes the completeness of the critical pair, designs and optimizes an algorithm to detect efficiently parallel evolution conflicts of software architectures using the critical pair. Finally, a tool support is used to evaluate the effectiveness of the proposed method.

Modeling and Maintaining Runtime Software Architectures

2014 ◽  
Vol 24 (8) ◽  
pp. 1731-1745 ◽  
Author(s):  
Hui SONG ◽  
Gang HUANG ◽  
Yi-Han WU ◽  
CHAUVEL Franck ◽  
Yan-Chun SUN ◽  
...  
Keyword(s):  
Software Architectures

SAAM: A Method for Analyzing the Properties of Software Architectures

2007 ◽  
Author(s):  
Rick Kazman ◽  
Len Bass ◽  
Gregory Abowd ◽  
Mike Webb
Keyword(s):  
Software Architectures

scholarly journals Reasoning with the HERMIT: tool support for equational reasoning on GHC core programs

2016 ◽  
Vol 50 (12) ◽  
pp. 23-34 ◽  
Author(s):  
Andrew Farmer ◽  
Neil Sculthorpe ◽  
Andy Gill
Keyword(s):  
Tool Support ◽  
Equational Reasoning

scholarly journals Correct program parallelisations

2021 ◽  
Author(s):  
S. Blom ◽  
S. Darabi ◽  
M. Huisman ◽  
M. Safari
Keyword(s):  
Composition Operators ◽  
Parallel Programs ◽  
Parallel Program ◽  
Tool Support ◽  
Intermediate Representation ◽  
Data Race ◽  
Sequential Program ◽  
Functional Correctness ◽  
Correct Program ◽  
Basic Blocks

AbstractA commonly used approach to develop deterministic parallel programs is to augment a sequential program with compiler directives that indicate which program blocks may potentially be executed in parallel. This paper develops a verification technique to reason about such compiler directives, in particular to show that they do not change the behaviour of the program. Moreover, the verification technique is tool-supported and can be combined with proving functional correctness of the program. To develop our verification technique, we propose a simple intermediate representation (syntax and semantics) that captures the main forms of deterministic parallel programs. This language distinguishes three kinds of basic blocks: parallel, vectorised and sequential blocks, which can be composed using three different composition operators: sequential, parallel and fusion composition. We show how a widely used subset of OpenMP can be encoded into this intermediate representation. Our verification technique builds on the notion of iteration contract to specify the behaviour of basic blocks; we show that if iteration contracts are manually specified for single blocks, then that is sufficient to automatically reason about data race freedom of the composed program. Moreover, we also show that it is sufficient to establish functional correctness on a linearised version of the original program to conclude functional correctness of the parallel program. Finally, we exemplify our approach on an example OpenMP program, and we discuss how tool support is provided.

Sign in / Sign up

Export Citation Format

Share Document