Automated conflict-free distributed implementation of component-based models

Bonakdarpour, Borzoo; Bozga, Marius; Jaber, Mohamad; Quilbeuf, Jean; Sifakis, Joseph

doi:10.1109/sies.2010.5551377

Cited by 18 publications

(37 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We conducted a set of experiments [16,13] to analyze the behavior and performance of the generated code using different scenarios (i.e., different partitioning of interactions, choice of committee coordination algorithm, mapping). Our experiments clearly show that particular configurations are suitable for different topology, size of the distributed system, communication load, and of course, the structure of the initial BIP model.…”

Section: Generating Distributed Implementationsmentioning

confidence: 99%

Rigorous System Design: The BIP Approach

Basu

Bensalem

Bozga

et al. 2012

Mathematical and Engineering Methods in Computer Science

Self Cite

View full text Add to dashboard Cite

Abstract. Rigorous system design requires the use of a single powerful component framework allowing the representation of the designed system at different levels of detail, from application software to its implementation. This is essential for ensuring the overall coherency and correctness. The paper introduces a rigorous design flow based on the BIP (Behavior, Interaction, Priority) component framework [1]. This design flow relies on several, tool-supported, source-to-source transformations allowing to progressively and correctly transform high level application software towards efficient implementations for specific platforms. System DesignTraditional engineering disciplines such as civil or mechanical engineering are based on solid theory for building artifacts with predictable behavior over their life-time. In contrast, we lack similar constructivity results for computing engineering: computer science provides only partial answers to particular system design problems. With few exceptions in this domain, predictability is impossible to guarantee at design time and therefore, a posteriori validation remains the only means for ensuring their correct operation.System design is facing several difficulties, mainly due to our inability to predict the behavior of an application software running on a given platform. Usually, systems are built by reusing and assembling components that are, simpler subsystems. This is the only way to master complexity and to ensure correctness of the overall design, while maintaining or increasing productivity. However, system level integration becomes extremely hard because components are usually highly heterogeneous: they have different characteristics, are often developed using different technologies, and highlight different features from different viewpoints. Other difficulties stem from current design approaches, often empirical and based on expertise and experience of design teams. Naturally, designers attempt to solve new problems by reusing, extending and improving existing solutions proven to be efficient and robust. This favors component reuse and avoids re-inventing and re-discovering designs. Nevertheless, on a longer term perspective, this may also be counter-productive: designers are not always able to adapt in a satisfactory manner to new requirements. Moreover, they a priori exclude better solutions simply because they do not fit their know-how.

show abstract

Section: Generating Distributed Implementationsmentioning

confidence: 99%

Rigorous System Design: The BIP Approach

Basu

Bensalem

Bozga

et al. 2012

Mathematical and Engineering Methods in Computer Science

Self Cite

View full text Add to dashboard Cite

show abstract

“…The BIP toolset provides us with means for generating C++ multi-threaded [3] as well as distributed [7] code from high-level BIP models. This feature enables us to evaluate the performance of distributed algorithms described by high-level models.…”

Section: Performance Evaluationmentioning

confidence: 99%

“…Interactions are expressed by combining two protocols: rendezvous and broadcast, which makes BIP more expressive than any formalism based on a single type of interaction [6]. Supporting tools of BIP's theory include techniques for model verification [20] as well as for generating from a high-level model an observationally equivalent multi-threaded or distributed implementation [3,7,8].…”

mentioning

confidence: 99%

“…We verify these properties on our BIP model for distributed reset by using model checking techniques. -Finally, a multi-threaded or distributed executable C++ code is automatically generated from the high-level model for simulations and experiments [3,7,8]. This C++ code faithfully represents an actual multi-threaded or distributed implementation of the high-level model.…”

mentioning

confidence: 99%

“…This C++ code faithfully represents an actual multi-threaded or distributed implementation of the high-level model. It is obtained by applying two transformations preserving observational equivalence [3,7,8]: (1) multi-party interactions are substituted by protocols based on asynchronous message passing; (2) the state of a component is undefined (due to concurrency) when it performs some internal computation. In this paper, we use a multi-threaded implementation in order to conduct guided simulations for estimating performance of distributed reset.…”

mentioning

confidence: 99%

See 2 more Smart Citations

Systematic Correct Construction of Self-stabilizing Systems: A Case Study

Basu

Bonakdarpour

Bozga

et al. 2010

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

Abstract. Design and implementation of distributed algorithms often involve many subtleties due to their complex structure, non-determinism, and low atomicity as well as occurrence of unanticipated physical events such as faults. Thus, constructing correct distributed systems has always been a challenge and often subject to serious errors. We present a methodology for component-based modeling, verification, and performance evaluation of self-stabilizing systems based on the BIP framework. In BIP, a system is modeled as the composition of a set of atomic components by using two types of operators: interactions describing synchronization constraints between components, and priorities to specify scheduling constraints. The methodology involves three steps illustrated using the distributed reset algorithm due to Arora and Gouda. First, a high-level model of the algorithm is built in BIP from the set of its processes by using powerful primitives for multi-party interactions and scheduling. Then, we use this model for verification of properties of a self-stabilizing algorithm including closure, deadlock-freedom, and finite reachability of the set of legitimate states. Finally, a distributed model which is observationally equivalent to the high-level model is generated. This model is used for performance analysis taking into account the degree of parallelism and convergence times for failure-free behavior as well as in the presence of faults.

show abstract

Hampa: Solver-Aided Recency-Aware Replication

Houshmand

Lesani

2020

Computer Aided Verification

View full text Add to dashboard Cite

Replication is a common technique to build reliable and scalable systems. Traditional strong consistency maintains the same total order of operations across replicas. This total order is the source of multiple desirable consistency properties: integrity, convergence and recency. However, maintaining the total order has proven to inhibit availability and performance. Weaker notions exhibit responsiveness and scalability; however, they forfeit the total order and hence its favorable properties. This project revives these properties with as little coordination as possible. It presents a tool called that given a sequential object with the declaration of its integrity and recency requirements, automatically synthesizes a correct-by-construction replicated object that simultaneously guarantees the three properties. It features a relational object specification language and a syntax-directed analysis that infers optimum staleness bounds. Further, it defines coordination-avoidance conditions and the operational semantics of replicated systems that provably guarantees the three properties. It characterizes the computational power and presents a protocol for recency-aware objects. uses automatic solvers statically and embeds them in the runtime to dynamically decide the validity of coordination-avoidance conditions. The experiments show that recency-aware objects reduce coordination and response time.

show abstract

Automated conflict-free distributed implementation of component-based models

Cited by 18 publications

References 16 publications

Rigorous System Design: The BIP Approach

Rigorous System Design: The BIP Approach

Systematic Correct Construction of Self-stabilizing Systems: A Case Study

Hampa: Solver-Aided Recency-Aware Replication

Contact Info

Product

Resources

About