## Abstract

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.

## References

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

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

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

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

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

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

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

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

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

## Author information

### Authors and Affiliations

### Corresponding author

## 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

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:

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:

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:

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* :

If there is an element *a* ∈ *U* 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*):

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

## About this article

### 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). https://doi.org/10.1007/s12083-014-0293-z

Received:

Accepted:

Published:

Issue Date:

DOI: https://doi.org/10.1007/s12083-014-0293-z

### Keywords

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