840 research outputs found
Port Protocols for Deadlock-Freedom of Component Systems
In component-based development, approaches for property verification exist
that avoid building the global system behavior of the component model.
Typically, these approaches rely on the analysis of the local behavior of fixed
sized subsystems of components. In our approach, we want to avoid not only the
analysis of the global behavior but also of the local behaviors of the
components. Instead, we consider very small parts of the local behaviors called
port protocols that suffice to verify properties.Comment: In Proceedings ICE 2010, arXiv:1010.530
gCSP: A Graphical Tool for Designing CSP systems
For broad acceptance of an engineering paradigm, a graphical notation and a supporting design tool seem necessary. This paper discusses certain issues of developing a design environment for building systems based on CSP. Some of the issues discussed depend specifically on the underlying theory of CSP, while a number of them are common for any graphical notation and supporting tools, such as provisions for complexity management and design overview
Reachability in Cooperating Systems with Architectural Constraints is PSPACE-Complete
The reachability problem in cooperating systems is known to be
PSPACE-complete. We show here that this problem remains PSPACE-complete when we
restrict the communication structure between the subsystems in various ways.
For this purpose we introduce two basic and incomparable subclasses of
cooperating systems that occur often in practice and provide respective
reductions. The subclasses we consider consist of cooperating systems the
communication structure of which forms a line respectively a star.Comment: In Proceedings GRAPHITE 2013, arXiv:1312.706
Software components and formal methods from a computational viewpoint
Software components and the methodology of component-based development offer a promising approach to master the design complexity of huge software products because they separate the concerns of software architecture from individual component behavior and allow for reusability of components. In combination with formal methods, the specification of a formal component model of the later software product or system allows for establishing and verifying important system properties in an automatic and convenient way, which positively contributes to the overall correctness of the system. Here, we study such a combined approach. As similar approaches, we also face the so-called state space explosion problem which makes property verification computationally hard. In order to cope with this problem, we derive techniques that are guaranteed to work in polynomial time in the size of the specification of the system under analysis, i.e., we put an emphasis on the computational viewpoint of verification. As a consequence, we consider interesting subclasses of component-based systems that are amenable to such analysis. We are particularly interested in ideas that exploit the compositionality of the component model and refrain from understanding a system as a monolithic block. The assumptions that accompany the set of systems that are verifiable with our techniques can be interpreted as general design rules that forbid to build systems at will in order to gain efficient verification techniques. The compositional nature of software components thereby offers development strategies that lead to systems that are correct by construction. Moreover, this nature also facilitates compositional reduction techniques that allow to reduce a given model to the core that is relevant for verification. We consider properties specified in Computation Tree Logic and put an emphasis on the property of deadlock-freedom. We use the framework of interaction systems as the formal component model, but our results carry over to other formal models for component-based development. We include several examples and evaluate some ideas with respect to experiments with a prototype implementation
Application of Deadlock Risk Evaluation of Architectural Models
Software architectural evaluation is a key discipline used to identify, at early stages of a real-time system (RTS) development, the problems that may arise during its operation. Typical mechanisms supporting concurrency, such as semaphores, mutexes or monitors, usually lead to concurrency problems in execution time that are difficult to be identified, reproduced and solved. For this reason, it is crucial to understand the root causes of these problems and to provide support to identify and mitigate them at early stages of the system lifecycle. This paper aims to present the results of a research work oriented to the development of the tool called âDeadlock Risk Evaluation of Architectural Modelsâ (DREAM) to assess deadlock risk in architectural models of an RTS. A particular architectural style, Pipelines of Processes in Object-Oriented ArchitecturesâUML (PPOOA) was used to represent platform-independent models of an RTS architecture supported by the PPOOA âVisio tool. We validated the technique presented here by using several case studies related to RTS development and comparing our results with those from other deadlock detection approaches, supported by different tools. Here we present two of these case studies, one related to avionics and the other to planetary exploration robotics. Copyright © 2011 John Wiley & Sons, Ltd
An Abstract Framework for Deadlock Prevention in BIP
Part 6: Session 5: Model CheckingInternational audienceWe present a sound but incomplete criterion for checking deadlock freedom of finite state systems expressed in BIP: a component-based framework for the construction of complex distributed systems. Since deciding deadlock-freedom for finite-state concurrent systems is PSPACE-complete, our criterion gives up completeness in return for tractability of evaluation. Our criterion can be evaluated by model-checking subsystems of the overall large system. The size of these subsystems depends only on the local topology of direct interaction between components, and not on the number of components in the overall system. We present two experiments, in which our method compares favorably with existing approaches. For example, in verifying deadlock freedom of dining philosphers, our method shows linear increase in computation time with the number of philosophers, whereas other methods (even those that use abstraction) show super-linear increase, due to state-explosion
- âŠ