Compound Module BambooModules

File: Overlay/Bamboo/Bamboo.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

bamboo: Bamboo 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.

Bamboo

The main module of the Pastry implementation

PastryLeafSet

This module contains the leaf set 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.

PastryNeighborhoodSet

This module contains the neighborhood set of the Pastry implementation.

PastryRoutingTable

This module contains the routing table of the Pastry implementation.

PastryRoutingTable

This module contains the routing table of the Pastry implementation.

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
bamboo.keyLength numeric

length of Overlay Key

bamboo.localPort numeric

UDP port for Pastry messages

bamboo.debugOutput bool

enable debug output

bamboo.hopCountMax numeric

maximum number of overlay hops

bamboo.joinOnApplicationRequest bool

only join the overlay on application request

bamboo.drawOverlayTopology bool

draw arrow to successor node?

bamboo.recNumRedundantNodes numeric

numRedundantNodes for recursive routing

bamboo.routingType string

default routing mode (iterative, semi-recursive,...)

bamboo.collectPerHopDelay bool

delay statistics for single hops

bamboo.lookupRedundantNodes numeric

number of next hops in each step

bamboo.lookupParallelPaths numeric

number of parallel paths

bamboo.lookupParallelRpcs numeric

number of nodes to ask in parallel

bamboo.lookupSecure bool

true, if all nodes should be identified with a ping

bamboo.lookupMerge bool

true, if parallel Rpc results should be merged

bamboo.lookupStrictParallelRpcs bool

limited the number of concurrent rpcs to parameter parallelRpcs

bamboo.lookupUseAllParallelResponses bool

merge all parallel responses from earlier steps

bamboo.lookupNewRpcOnEveryTimeout bool

send a new RPC immediately after an RPC timeouts

bamboo.lookupNewRpcOnEveryResponse bool

send a new RPC after every response, even if there was no progress

bamboo.lookupFinishOnFirstUnchanged bool

finish lookup, if the last pending RPC returned without progress

bamboo.lookupFailedNodeRpcs bool

communicate failed nodes

bamboo.enableNewLeafs bool

enable Pastry API call newLeafs()

bamboo.useCommonAPIforward bool

enable forwarding of routeMessages to app before routing them

bamboo.routeMsgAcks bool

use RPCs for route messages

bamboo.optimizeLookup bool

whether to search the closest node in findCloserNode() calls

bamboo.optimisticForward bool

forward message immediately in recursive mode, otherwise ping first

bamboo.avoidDuplicates bool

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

bamboo.partialJoinPath bool

allow join even with missing state message along the routing path

bamboo.bitsPerDigit numeric

bits per Pastry digit

bamboo.numberOfLeaves numeric

number of entries in leaf set

bamboo.numberOfNeighbors numeric

number of entries in neighborhoot set

bamboo.joinTimeout numeric

seconds to wait for STATE message from closest node

bamboo.readyWait numeric

seconds to wait for missing state messages in JOIN phase

bamboo.repairTimeout numeric

how long to wait for repair messages

bamboo.sendStateWaitAmount numeric

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

bamboo.pingTimeout numeric

how long to wait for PING reply

bamboo.pingRetries numeric

how often to retry PING after timeout

bamboo.useRegularNextHop bool
bamboo.alwaysSendUpdate bool
bamboo.coordBasedRouting bool

use coord-based routing

bamboo.numCoordDigits numeric

numbner of digits used for coord-based routing

bamboo.CBRstartAtDigit numeric

start at this digit using CBR

bamboo.CBRstopAtDigit numeric

stop at this digit using CBR

bamboo.repairTaskTimeoutAmount numeric

discoveryTimeoutAmount: numeric, // how long to wait for leafset pings in discovery stage

bamboo.leafsetMaintenanceTimeoutAmount numeric

leafset push/pull interval

bamboo.globalTuningTimeoutAmount numeric

global tuning interval

Source code:

module BambooModules
    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:
        bamboo: Bamboo;
            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 --> bamboo.from_udp++;
        to_udp <-- bamboo.to_udp++;
        from_app --> bamboo.from_app;
        to_app <-- bamboo.to_app;

endmodule