Round-based Model Research Articles

Formal modeling and analysis of time- and resource-sensitive simple business processes

A time- and resource-sensitive simple business process (TR-SBP) consists of a finite set of finite series of activities that have timing and resource constraints. A TR-SBP seems simple, but its analysis needs to consider what are not explicitly mentioned as activities and may introduce a non-negligible number of intermediate states. In this sense, the analysis has similarities with security protocol analysis that needs to consider intruders. We formalize TR-SBPs as a round-based model called Formal TR-SBPs in this paper. We describe how to specify Formal TR-SBPs in Maude, a specification language based on rewriting logic and Alloy, a specification language based on first-order relational logic, and how to analyze Formal TR-SBPs based on those specifications with Maude and Alloy. A nursing problem is used as an example of TR-SBPs in this paper.

Timing analysis of leader-based and decentralized Byzantine consensus algorithms

Abstract We consider the Byzantine consensus problem in a partially synchronous system with strong validity. For this problem, two main algorithms—with different resilience—are described in the literature. These two algorithms assume a leader process. A decentralized variant (variant without leader) of these two algorithms has also been given in a previous paper. Here, we compare analytically, in a round-based model, the leader-based variant of these algorithms with the decentralized variant. We show that, in most cases, the decentralized variant of the algorithm has a better worst-case execution time. Moreover, for the practically relevant case t≤2 (where t is the maximum number of Byzantine processes), this worst-case execution time is even at least as good as the execution time of the leader-based algorithms in fault-free runs.

The perfectly synchronized round-based model of distributed computing

The perfectly synchronized round-based model provides the powerful abstraction of crash-stop failures with atomic and synchronous message delivery. This abstraction makes distributed programming very easy. We describe a technique to automatically transform protocols devised in the perfectly synchronized round-based model into protocols for the crash, send omission, general omission or Byzantine models. Our transformation is achieved using a round shifting technique with a constant time complexity overhead. The overhead depends on the target model: crashes, send omissions, general omissions or Byzantine failures. Rather surprisingly, we show that no other automatic non-uniform transformation from a weaker model, say from the traditional crash-stop model (with no atomic message delivery), onto an even stronger model than the general-omission one, say the send-omission model, can provide a better time complexity performance in a failure-free execution.