Analyzing the exhaustiveness of the Synapse protocol

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.

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 ₁, …, t _n , t are first-order terms. To fire this rule in a state S evaluate all terms t ₁, …, t _n , t at S and update the function f to [t] _S on parameters [t ₁] _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 ₁, R ₂ are transition rules. To fire that new rule in a state S evaluate the guard; if it is true, then execute R ₁, otherwise execute R ₂. The else part may be omitted.

The seq constructor produces transition rules of the form:

to apply R ₁, …, 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 ₁, …, 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 ₀;S ₁;… where S ₀ 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 ₀;S ₁;…;S _n ;… of states of $\mathcal {A}$, where S ₀ 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.