Compound Module PastryModules

File: Overlay/Pastry/Pastry.ned

Implementation of the Pastry KBR overlay as described in "Pastry: Scalable, Decentralized Object Location, and Routing for Large-Scale Peer-to-Peer Systems" by Antony Rowstron and Peter Druschel, published in Lecture Notes in Computer Science, volume 2218.

Author: Felix Palmen

pastry: Pastry pastryRoutingTable: PastryRoutingTable pastryLeafSet: PastryLeafSet pastryNeighborhoodSet: PastryNeighborhoodSet

Usage diagram:

The following diagram shows usage relationships between modules, networks and channels. Unresolved module (and channel) types are missing from the diagram. Click here to see the full picture.

Contains the following modules:

If a module type shows up more than once, that means it has been defined in more than one NED file.

Pastry

The main module of the Pastry implementation

PastryLeafSet

This module contains the leaf set of the Pastry implementation.

PastryNeighborhoodSet

This module contains the neighborhood set of the Pastry implementation.

PastryRoutingTable

This module contains the routing table of the Pastry implementation.

Parameters:

Name Type Description
keyLength numeric

length of Overlay Key

localPort numeric

UDP port for Pastry messages

debugOutput bool

enable debug output

joinOnApplicationRequest bool

only join the overlay on application request

useNextHopRpc bool
iterativeLookup bool

do iterative instead of recursive lookups

useCommonAPIforward bool

enable forwarding of routeMessages to app before routing them

lookupRedundantNodes numeric

number of next hops in each step

lookupParallelPaths numeric

number of parallel paths

lookupParallelRpcs numeric

number of nodes to ask in parallel

lookupSecure bool

true, if all nodes should be identified with a ping

lookupMerge bool

true, if parallel Rpc results should be merged

lookupFailedNodeRpcs bool

communicate failed nodes

measureNetwInitPhase bool

gather statistics when bootstrapping

collectPerHopDelay bool

delay statistics for single hops

hopCountMax numeric

maximum number of overlay hops

drawOverlayTopology bool

draw arrow to successor node?

Gates:

Name Direction Description
from_udp input

gate from the UDP layer

to_udp output

gate to the UDP layer

from_app input

gate from the application

to_app output

gate to the application

Unassigned submodule parameters:

Name Type Description
pastry.enableNewLeafs bool

enable Pastry API call newLeafs()

pastry.optimizeLookup bool

whether to search the closest node in findCloserNode() calls

pastry.optimisticForward bool

forward message immediately in recursive mode, otherwise ping first

pastry.avoidDuplicates bool

when node seems unreachable but msg already sent, do not retry

pastry.partialJoinPath bool

allow join even with missing state message along the routing path

pastry.bitsPerDigit numeric

bits per Pastry digit

pastry.numberOfLeaves numeric

number of entries in leaf set

pastry.numberOfNeighbors numeric

number of entries in neighborhoot set

pastry.joinTimeout numeric

seconds to wait for STATE message from closest node

pastry.readyWait numeric

seconds to wait for missing state messages in JOIN phase

pastry.secondStageWait numeric

how long to wait before starting second stage of init phase

pastry.pingCacheExpireTime numeric

maximum number of seconds rtt for a node is cached

pastry.repairTimeout numeric

how long to wait for repair messages

pastry.ringCheckInterval numeric

check direct neighbors on the ring every x seconds (0 to disable)

pastry.sendStateWaitAmount numeric

how long to wait when sending state tables delayed (should be very small)

pastry.pingTimeout numeric

how long to wait for PING reply

pastry.pingRetries numeric

how often to retry PING after timeout

pastry.useRegularNextHop bool
pastry.alwaysSendUpdate bool
pastry.coordBasedRouting bool

use coord-based routing

pastry.numCoordDigits numeric

numbner of digits used for coord-based routing

pastry.CBRstartAtDigit numeric

start at this digit using CBR

pastry.CBRstopAtDigit numeric

stop at this digit using CBR

Source code:

module PastryModules

    parameters:
        keyLength: numeric,              // length of Overlay Key
        localPort: numeric,              // UDP port for Pastry messages
        debugOutput: bool,               // enable debug output
        // only join the overlay on application request
        joinOnApplicationRequest: bool,
        useNextHopRpc : bool,
        iterativeLookup: bool,          // do iterative instead of recursive
                                        // lookups
        useCommonAPIforward : bool,     // enable forwarding of routeMessages to
                                        // app before routing them                                
         
        lookupRedundantNodes: numeric,   // number of next hops in each step
        lookupParallelPaths: numeric,    // number of parallel paths
        lookupParallelRpcs: numeric,     // number of nodes to ask in parallel
        // true, if all nodes should be identified with a ping
        lookupSecure: bool,
        // true, if parallel Rpc results should be merged    
        lookupMerge: bool,    
        lookupFailedNodeRpcs: bool,      // communicate failed nodes

        measureNetwInitPhase: bool,      // gather statistics when bootstrapping
        collectPerHopDelay : bool,       // delay statistics for single hops
        hopCountMax: numeric,            // maximum number of overlay hops
        drawOverlayTopology: bool;       // draw arrow to successor node?

    gates:
        in: from_udp;   // gate from the UDP layer
        out: to_udp;    // gate to the UDP layer
        in: from_app;   // gate from the application
        out: to_app;    // gate to the application

    submodules:
        pastry: Pastry;
            parameters:
                keyLength = keyLength,     // length of Overlay Key
                localPort = localPort,     // UDP port for Pastry messages
                debugOutput = debugOutput, // enable debug output
                // only join the overlay on application request
                joinOnApplicationRequest = joinOnApplicationRequest, 
                useNextHopRpc = useNextHopRpc,
                // do iterative instead of recursive lookups
                iterativeLookup = iterativeLookup,
                // enable forwarding of routeMessages to app before routing them     
                useCommonAPIforward = useCommonAPIforward,   
                // number of next hops in each step  
                lookupRedundantNodes = lookupRedundantNodes,    
                // number of parallel paths
                lookupParallelPaths = lookupParallelPaths,  
                // number of nodes to ask in parallel  
                lookupParallelRpcs = lookupParallelRpcs,
                // true, if all nodes should be identified with a ping    
                lookupSecure = lookupSecure,  
                // true, if parallel Rpc results should be merged  
                lookupMerge = lookupMerge,    
                // communicate failed nodes
                lookupFailedNodeRpcs = lookupFailedNodeRpcs,    
                // gather statistics when bootstrapping
                measureNetwInitPhase = measureNetwInitPhase,
                // delay statistics for single hops    
                collectPerHopDelay = collectPerHopDelay,
                // maximum number of overlay hops    
                hopCountMax = hopCountMax,    
                // draw arrow to successor node?
                drawOverlayTopology = drawOverlayTopology;    
            display: "p=60,52;i=block/circle";
    pastryRoutingTable: PastryRoutingTable;
        display: "p=140,68;i=block/table";
    pastryLeafSet: PastryLeafSet;
        display: "p=220,52;i=block/table";
    pastryNeighborhoodSet: PastryNeighborhoodSet;
        display: "p=300,68;i=block/table";

    connections nocheck:
        from_udp --> pastry.from_udp++;
        to_udp <-- pastry.to_udp++;
        from_app --> pastry.from_app;
        to_app <-- pastry.to_app;

endmodule