Skip to main content

Analyzing the exhaustiveness of the Synapse protocol


The Synapse protocol is a scalable protocol designed for information retrieval over inter-connected heterogeneous overlay networks. In this paper, we give a formal description of Synapse using the Abstract State Machines framework. The formal description pertains to Synapse actions that manipulate distributed keys. Based on this formal description, we present results concerning the expected exhaustiveness for a number of scenarios and systems maintained by the Synapse protocol, and provide comparisons to the results of the corresponding simulations and experiments. We show that the predicted theoretical results match the obtained experimental results, and give recommendations on the design of systems using Synapse.

This is a preview of subscription content, access via your institution.

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7
Fig. 8


  1. Börger E, Stärk R (2003) Abstract state machines a method for high-level system design and analysis. Springer-Verlag

  2. Ciancaglini V, Liquori L, Vanni L (2010) CarPal: interconnecting overlay networks for a community-driven shared mobility. In: TGC 2010. International symposium on trustworthy global computing. Lecture Notes in Computer Science, vol 6084. Springer-Verlag, pp 301–317

  3. Gurevich Y (1995) Evolving algebras 1993: Lipari guide. In: Specification and validation methods. Oxford University Press, pp 9–36

  4. Gurevich Y (2000) Sequential abstract state machines capture sequential algorithms. ACM Trans Comput Logic 1 (1): 77–111

    Article  MathSciNet  Google Scholar 

  5. Liquori L, Tedeschi C, Vanni L, Bongiovanni F, Ciancaglini V, Marinković B (2010) Synapse: a scalable protocol for interconnecting heterogeneous overlay networks. In: Networking 2010. Lecture notes in computer science, vol 6091 (p. 410). pp 67–82

  6. Ciancaglini V, Hoang GN, Liquori L (2011) Towards a common architecture to interconnect heterogeneous overlay networks. In: ICPADS 2011. IEEE, pp 817–822

  7. Ciancaglini V, Hoang GN, Maksimović P, Liquori L (2012) An extension and cooperation mechanism for heterogeneous overlay networks. In: Networking 2012. Lecture notes in computer science, vol 7291. pp 10–18

  8. Marinković B, Liquori L, Ciancaglini V, Ognjanović Z (2011) A distributed catalog for digitized cultural heritage. In: ICT innovations 2010, CCIS 83. pp 176–186

  9. Marinković B, Glavan P, Ognjanović Z Formal description of the chord protocol using ASM. At arXiv: 1208.0712v1

Download references

Author information

Authors and Affiliations


Corresponding author

Correspondence to Bojan Marinković.

Additional information

The work presented in this paper was supported by the Serbian Ministry of Education, Science and Technological Development, projects ON174026 and III44006, through Matematički Institut SANU and by Ministarstvo znanosti, obrazovanja i športa republike Hrvatske.

Appendix: Abstract State Machines

Appendix: Abstract State Machines

We assume that the reader is familiar with the semantics of the Abstract State Machine defined in [1, 3, 4], and we quote here only the essential definitions.

A Gurevich’s Abstract State Machine \(\mathcal {A}\) is defined by a program Prog - consisting of a finite number of transition rules, at most countable set of states and initial states. \(\mathcal {A}\) models the operational behavior of a real dynamic system \(\mathcal {S}\) in terms of evolution of states.

A state S is a first-order structure over a fixed signature (which is also the signature of \(\mathcal {A}\)), representing the instantaneous configuration of \(\mathcal {S}\). The value of a term t at \(\mathcal {S}\) is denoted by [t] S . The basic transition rule is the following function update

$$f(t_{1}, {\ldots} , t_{n}) := t,$$

where f is an arbitrary n-ary function and t 1, …, t n , t are first-order terms. To fire this rule in a state S evaluate all terms t 1, …, t n , t at S and update the function f to [t] S on parameters [t 1] S , …, [t n ] S . This produces another state S which differs from S only in the new interpretation of the function f (since states represent memory, function update represents change in the content of one memory location).

Additionally, we have the following transition rules.

The conditional constructor produces “guarded” transition rules of the form:

figure b

where g is a ground term (the guard of the rule) and R 1, R 2 are transition rules. To fire that new rule in a state S evaluate the guard; if it is true, then execute R 1, otherwise execute R 2. The else part may be omitted.

The seq constructor produces transition rules of the form:

figure c

to apply R 1, …, R n sequentially. Note that the seq-constructor is originally defined without the endseq-line, but we add it to improve readability.

The par constructor produces transition rules of the form:

figure d

to apply R 1, …, R n simultaneously, when possible, otherwise do nothing.

If U is a universe name, v is a variable, g(v) is a Boolean term and R is a rule then the following expression (choose constructor) is a rule with the main existential variable v that ranges over U and body R :

figure e

If there is an element aU such that condition g(a) is true, fire rule R (with a substituted for v), otherwise do nothing.

To express the simultaneous execution of a rule R for each x satisfying a given condition φ (forall constructor):

figure f

A run/computation of \(\mathcal {A}\) is a finite or infinite sequence S 0;S 1;… where S 0 is an initial state and every S i+1 is obtained from S i executing a transition rule.

In general runs may be affected by the environment. Environment manifests itself via so-called external functions. Every external function can be understand as a (dynamic) oracle. The ASM provides the arguments and the oracle gives the result.

In a distributed Gurevich’s Abstract State Machine \(\mathcal {A}\) multiple autonomous agents cooperatively model a concurrent computation of \(\mathcal {S}\). Each agent a executes its own single-agent program Prog(a) as specified by the module associated with a by the function Mod. More precisely, an agent a has a partial view View(a;S) of a given global state S as defined by its sub-vocabulary Fun(a) (i.e. the function names occurring in Prog(a)) and it can make a move at S by firing Prog(a) at View(a;S) and changing S accordingly. The underlying semantic model ensures that the order in which the agents of \(\mathcal {A}\) perform their actions is always such that no conflicts between the update sets computed for distinct agents can arise. The global program Prog is the union of all single-agent programs. Nullary function Me, that allows an agent to identify itself among other agents, is interpreted as a for each agent a, and does not belong to Fun(a) for any agent a. It cannot be the subject of an update instruction and is used to parameterize the agent’s specific functions. A sequential run of a distributed Gurevich’s Abstract State machine \(\mathcal {A}\) is a (finite or infinite) sequence S 0;S 1;…;S n ;… of states of \(\mathcal {A}\), where S 0 is an initial state and every S n+1 is obtained from S n by executing a move of an agent. The partially ordered run, defined in [3], is the most general definition of runs for a distributed ASM. In order to prove properties on a partially ordered run, the attention may be restricted to a linearization of it, which is, in turn, a sequential run (see [3] for more explanations). In the rest of the paper we consider only regular runs in which a state is global and moves of agents are atomic.

Rights and permissions

Reprints and Permissions

About this article

Verify currency and authenticity via CrossMark

Cite this article

Marinković, B., Ciancaglini, V., Ognjanović, Z. et al. Analyzing the exhaustiveness of the Synapse protocol. Peer-to-Peer Netw. Appl. 8, 793–806 (2015).

Download citation

  • Received:

  • Accepted:

  • Published:

  • Issue Date:

  • DOI:


  • Peer-to-peer
  • DHT-based overlay networks
  • Abstract State Machines
  • Retrieval probability