Overlay Algorithms

These overlay algorithms are currently supported:

SCAMP

SCAMP is based on the paper "SCAMP: Peer-to-peer lightweight membership service for large-scale group communication"
SCAMP maintains a unidirectional overlay designed to keep the average number of neighbors for each node at \log(n)(1+c), for a constant c >= 0, where n is the size of the network.
SCAMP bootstraps each new peer by sending a random seed peer form the bootstrap node.
Whenever a connection request is received, the peer forwards it to its neighbors along with c additional forward copies of the connection request.
Upon receiving a forwarded connection request, the peer adds the new connection with some probability.
To recover from failures, SCAMP peers that stop receiving messages restart the entire protocol using the bootstrap node or one of their neighbors.

<overlayAlgorithm algorithm="SCAMPOverlay" c="1">
    <clusteringAlgorithm algorithm="FullCluster" />
</overlayAlgorithm> 

SCAMP receives a single attribute - the c constant.
Also, SCAMP receives a clustering algorithm. [Clustering Algorithms]

BSCAMP

A bidirectional version of SCAMP, where all neighboring connections are mutual.
whenever a node adds a neighbor, it sends a message to the added node so that the new neighbor would add the node back.

<overlayAlgorithm algorithm="BSCAMPOverlay" c="1">
    <clusteringAlgorithm algorithm="FullCluster" />
</overlayAlgorithm> 

SCAMP receives a single attribute - the c constant.
Also, SCAMP receives a clustering algorithm. [Clustering Algorithms]

Coolstreaming overlay

Based on the paper: "CoolStreaming/DONet: a data-driven overlay network for peer-to-peer live media streaming"
Coolstreaming defines a protocol that is designed to keep a stable amount of neighbors defined by a custom system parameter M. As in SCAMP, a new peer begins its tenure by receiving a seed peer ("deputy") from the bootstrap node. The new peer sends a request to the seed (deputy) peer for additional nodes.
The peers then use SCAMP to disseminate membership messages. To manage the neighborhood, peers store a cache of known peers from the information received from the membership messages, and bias the cache
towards storing those nodes with whom the peer has exchanged a large number of chunks of the stream.
When the number of neighbors drops below M, a peer contacts a random peer in its cache with a connection request.

<overlayAlgorithm H="200" M="2" c="1" amountToSend="3" exploreRound="30" gossipTimeout="6"
        algorithm="CoolStreamingOverlay">
    <clusteringAlgorithm algorithm="FullCluster" />
</overlayAlgorithm>

Coolstreaming overlay eceives a clustering algorithm. [Clustering Algorithms]
And these parameters:

• M - target number of neighbors
• H - maximal allowed neighbors
• c - the constant for the underlying SCAMP protocol
• amountToSend - the number of mCache entries to send to each neighbor in a gossiping round
• exploreRound - the frequency in which slow neighbors are to dismissed (in this example, once per 30 rounds)
• gissipTimeout - seconds between each gossip of the mCache

Araneola

Araneola is based on the paper "Araneola: A scalable reliable multicast system for dynamic environments"
Araneola uses a separate overlay protocol for tracking its membership view.
Based on the Araneola membership service above, Araneola maintains an overlay that approximates a random regular graph. To bootstrap the Araneola overlay, nodes piggyback on the membership protocol by connecting to nodes in the current view. Nodes continually make connections and disconnect while striving to ensure that each node has exactly L (a configurable parameter) or L+1 neighbors.
Each node is aware of the degree of each of its neighbors through a periodic exchange of information.
When a peer is unable to accept a new connection because its degree is already L+1, it responds to the connect request with a AraneolaRedirectMessage along with its least loaded neighbor node as a hint to the connecting node.
To prevent disconnections in the overlay, Araneola nodes actively connects to other peers when their degree drops below L.

<overlayAlgorithm algorithm="AraneolaOverlay" S="12" gossipDelay="6" 
  amountToSend="3" L="3" H="10" connect_timeout="2" disconnect_timeout="2">
    <clusteringAlgorithm algorithm="FullCluster" />
</overlayAlgorithm> 

Araneola receives a clustering algorithm. [Clustering Algorithms]
And these parameters:

• S - membership view size
• gossipDelay - seconds between each gossip of the membership view
• amountToSend - amount of membership information to send on each gossiping round
• L - target number of neighbors
• H - upper bound on the number of neighbors
• connect_timeout - number of seconds between two consecutive runs of the connect task
• disconnect_timeout - number of seconds between two consecutive runs of the disconnect task

Prime overlay

Prime is based on the paper "Prime: Peer-to-peer receiver-driven mesh-based streaming"
In Prime, all neighbor nodes are defined as either parent nodes or child nodes.
The service is bootstrapped by requesting a random group of peers from the bootstrap node and sending these peers a connection request.
A node will send a connection request only if it has enough download bandwidth, and nodes will accept a connection request only if they have enough upload bandwidth.
When all the parents of a peer fail, the peer restarts the algorithm.

<overlayAlgorithm algorithm="PrimeOverlay" size="8">
    <clusteringAlgorithm algorithm="FullCluster" />
</overlayAlgorithm>

PrimeOverlay receives a single attribute - size that sets the amount of nodes the source replies with during the bootstrap.
Also, PrimeOverlay receives a clustering algorithm. [Clustering Algorithms]

TreeBone

The TreeBone overlay is used by mTreebone (mtreebone: A hybrid tree/mesh overlay for application-layer live video multicast). Initially, nodes choose a random node and become its children.
A node accepts another node request only if it has enough upload bandwidth to maintain a streaming connection at the desired rate.
Nodes with high uptime are viewed as stable and will gradually start joining other stable nodes near to the root of the tree.
Stable nodes also perform transformations that decrease the maximal and average depth of the tree.
Should the parent of a node die, the peer will look for a new parent.

<overlayAlgorithm algorithm="TreeBoneOverlay" stableCoefficient="0.3" queryTimeout="3">
    <clusteringAlgorithm algorithm="FullCluster" />
</overlayAlgorithm>

TreeBone receives a clustering algorithm. [Clustering Algorithms]
And these parameters:

• stableCoefficient - the coefficient of the remaining playback time when a node becomes stable.
• queryTimeout- timeout between rounds when a node initiates a query to find out about its ancestors