Compound Module ChordModules

File: Overlay/Chord/Chord.ned

Implementation of the Chord KBR overlay as described in "Chord: A Scalable Peer-to-Peer Lookup Protocol for Internet Applications" by I. Stoica et al. published in Transactions on Networking.

Author: Ingmar Baumgart, Markus Mauch

chord: Chord fingerTable: ChordFingerTable successorList: ChordSuccessorList

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.

Chord

The main module of the Chord implementation

ChordFingerTable

This modul contains the finger table of the Chord implementation.

ChordSuccessorList

This modul contains the successor list of the Chord 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
chord.localPort numeric

UDP port for Chord messages

chord.debugOutput bool

enable debug output

chord.keyLength numeric

overlay key length in bits

chord.useCommonAPIforward bool

enable CommonAPI forward() calls

chord.drawOverlayTopology bool

draw arrow to successor node?

chord.hopCountMax numeric

maximum number of overlay hops

chord.recNumRedundantNodes numeric

numRedundantNodes for recursive routing

chord.joinOnApplicationRequest bool

only join the overlay on application request

chord.collectPerHopDelay bool

delay statistics for single hops

chord.routeMsgAcks bool

use RPCs for route messages

chord.lookupRedundantNodes numeric

number of next hops in each step

chord.lookupParallelPaths numeric

number of parallel paths

chord.lookupParallelRpcs numeric

number of nodes to ask in parallel

chord.lookupSecure bool

true, if all nodes should be identified with a ping

chord.lookupMerge bool

true, if parallel Rpc results should be merged

chord.lookupFailedNodeRpcs bool

communicate failed nodes

chord.lookupStrictParallelRpcs bool

limited the number of concurrent rpcs to parameter parallelRpcs

chord.lookupUseAllParallelResponses bool

merge all parallel responses from earlier steps

chord.lookupNewRpcOnEveryTimeout bool

send a new RPC immediately after an RPC timeouts

chord.lookupNewRpcOnEveryResponse bool

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

chord.lookupFinishOnFirstUnchanged bool

finish lookup, if the last pending RPC returned without progress

chord.routingType string

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

chord.successorListSize numeric

max number of successors in the SuccessorList

chord.joinRetry numeric

after joinRetry unsuccessful join requests, we fetch a need bootstrap node from the BootstrapOracle

chord.stabilizeRetry numeric

retries before a successor is considered failed

chord.joinDelay numeric

delay between join retries (sec)

chord.stabilizeDelay numeric

stabilize interval (sec)

chord.fixfingersDelay numeric

fix_fingers interval (sec)

chord.aggressiveJoinMode bool

use modified (faster) JOIN protocol

chord.extendedFingerTable bool

use the extended finger table?

chord.numFingerCandidates numeric

number of fingers when using extended finger table

chord.proximityRouting bool

use proximity routing

chord.mergeOptimizationL1 bool

enable merge optimization OPL1

chord.mergeOptimizationL2 bool

activate merge optimization OPL2

chord.mergeOptimizationL3 bool

activate merge optimization OPL3

chord.mergeOptimizationL4 bool

activate merge optimization OPL4

Source code:

module ChordModules
    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:
        chord: Chord;
            display: "p=60,60;i=block/circle";

        fingerTable: ChordFingerTable;
            display: "p=150,60;i=block/table";
        successorList: ChordSuccessorList;
            display: "p=240,60;i=block/table";

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