Compound Module GiaModules

File: Overlay/Gia/Gia.ned

Implementation of the Gia overlay as described in "Making Gnutella-like P2P Systems Scalable" by Yatin Chawathe, Sylvia Ratnasamy, Lee Breslau, Nick Lanham and Scott Shenker, published in "In Proc. ACM SIGCOMM (Aug. 2003)".

Author: Robert Palmer

gia: Gia keyListModule: GiaKeyListModule neighbors: GiaNeighbors tokenFactory: GiaTokenFactory

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.

Gia

The main module of the GIA implementation

Author: Robert Palmer

GiaKeyListModule

Module for visualizing the keylist

Author: Robert Palmer

GiaNeighbors

Module which handles all current neighbors of the node. Contains capacity, connection degree, sent and received token count and the keylist of all neighbors

Author: Robert Palmer

GiaTokenFactory

Module for sending new tokens to direct neighbors

Author: Robert Palmer

Parameters:

Name Type Description
localPort numeric

local UDP-Port

debugOutput bool

use debug-output?

joinOnApplicationRequest bool

only join the overlay on application request

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

useCommonAPIforward bool

enable CommonAPI forward() calls

iterativeLookup bool
collectPerHopDelay bool

delay statistics for single hops

useNextHopRpc bool

use RPCs for route messages

measureNetwInitPhase bool

gather statistics when bootstrapping

drawOverlayTopology numeric

draw arrow to successor node?

hopCountMax numeric

maximum number of overlay hops

keyLength numeric

overlay key length in bits

Gates:

Name Direction Description
from_udp input

gate from UDP

to_udp output

gate to UDP

from_app input

gate from application

to_app output

gate to application

Unassigned submodule parameters:

Name Type Description
gia.maxNeighbors numeric

maximum number of neighbors

gia.minNeighbors numeric

minimum number of neighbors

gia.maxTopAdaptionInterval numeric

maximum topology adaption interval

gia.topAdaptionAggressiveness numeric

topology adaption aggressiveness

gia.maxLevelOfSatisfaction numeric

maximum level of satisfaction

gia.maxHopCount numeric

maximum TTL for sent messages

gia.messageTimeout numeric

message timeout

gia.neighborTimeout numeric

neighbor timeout

gia.sendTokenTimeout numeric

token timeout

gia.tokenWaitTime numeric

delay when sending new token

gia.keyListDelay numeric

delay when sending new key list to our neighbors

gia.updateDelay numeric

delay between two update messages

gia.outputNodeDetails bool

output node details

gia.optimizeReversePath bool

use optimized reverse path?

Source code:

module GiaModules

     parameters:
        localPort : numeric,             // local UDP-Port
        debugOutput : bool,              // use debug-output?
        // only join the overlay on application request
        joinOnApplicationRequest : bool, 
        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
        useCommonAPIforward : bool,      // enable CommonAPI forward() calls
        iterativeLookup : bool,            
        collectPerHopDelay : bool,       // delay statistics for single hops
        useNextHopRpc : bool,            // use RPCs for route messages
        measureNetwInitPhase : bool,     // gather statistics when bootstrapping
        drawOverlayTopology : numeric,   // draw arrow to successor node?
        hopCountMax : numeric,           // maximum number of overlay hops
        keyLength : numeric;             // overlay key length in bits

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

    submodules:
        gia: Gia;                          // gia main module
            parameters: 
                localPort = localPort,     // local UDP-Port
                debugOutput = debugOutput, // use debug output?
                // gather statistics when bootstrapping
                measureNetwInitPhase = measureNetwInitPhase,
                useCommonAPIforward = useCommonAPIforward,
                iterativeLookup = iterativeLookup,
                collectPerHopDelay = collectPerHopDelay,
                useNextHopRpc = useNextHopRpc,
                // only join the overlay on application request
                joinOnApplicationRequest = joinOnApplicationRequest,
                // 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,        

                // maximum number of overlay hops
                hopCountMax = hopCountMax,      
                // draw arrow to successor node?
                drawOverlayTopology = drawOverlayTopology,    
                // overlay key length in bits      
                keyLength = keyLength;                              

            display: "p=60,60;i=block/circle";  // display icon
        keyListModule: GiaKeyListModule;        // KeyList-Module
            display: "p=150,60;i=block/table";  // display icon
        neighbors: GiaNeighbors;                // Neigbors-Module
            display: "p=240,60;i=block/table";  // display icon
        tokenFactory: GiaTokenFactory;          // TokenFactory-Module
            display: "p=330,60;i=block/table";  // display icon
    connections nocheck:
        from_udp --> gia.from_udp++; // connect from_udp with gia.from_udp
        to_udp <-- gia.to_udp++;     // connect to_upd with gia.to_udp
        from_app --> gia.from_app;   // connect from_app with gia.from_app
        to_app <-- gia.to_app;       // connect to_app with gia.to_app

endmodule