File Overlay/Bamboo/Bamboo.ned

Contains:

//
// Copyright (C) 2006 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

//
// The main module of the Pastry implementation
//
// @author Felix Palmen
//
simple Bamboo

    parameters:
        keyLength: numeric,             // length of Overlay Key
        localPort: numeric,             // UDP port for Pastry messages
        debugOutput: bool,              // enable debug output
        hopCountMax: numeric,           // maximum number of overlay hops
        joinOnApplicationRequest: bool, // only join the overlay on application
                                        // request
        drawOverlayTopology: bool,      // draw arrow to successor node?
        recNumRedundantNodes : numeric, // numRedundantNodes for recursive routing
        routingType : string,           // default routing mode (iterative, semi-recursive,...)

        collectPerHopDelay : bool,      // delay statistics for single hops
        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
        lookupStrictParallelRpcs: bool, // limited the number of concurrent rpcs to parameter parallelRpcs
        lookupUseAllParallelResponses: bool, // merge all parallel responses from earlier steps
        lookupNewRpcOnEveryTimeout: bool, // send a new RPC immediately after an RPC timeouts
        lookupNewRpcOnEveryResponse: bool, // send a new RPC after every response, even if there was no progress
        lookupFinishOnFirstUnchanged: bool, // finish lookup, if the last pending RPC returned without progress                                        
        lookupFailedNodeRpcs : bool,    // communicate failed nodes
        enableNewLeafs : bool,          // enable Pastry API call newLeafs()
        useCommonAPIforward : bool,     // enable forwarding of routeMessages to app
                                        // before routing them
        routeMsgAcks : bool,           // use RPCs for route messages                                
        optimizeLookup : bool,          // whether to search the closest node
                                        // in findCloserNode() calls
        optimisticForward : bool,       // forward message immediately in
                                        // recursive mode, otherwise ping first
        avoidDuplicates : bool,         // when node seems unreachable but msg
                                        // already sent, do not retry
        partialJoinPath : bool,         // allow join even with missing state
                                        // message along the routing path
        bitsPerDigit: numeric,          // bits per Pastry digit
        numberOfLeaves: numeric,        // number of entries in leaf set
        numberOfNeighbors: numeric,     // number of entries in neighborhoot set
        joinTimeout: numeric,           // seconds to wait for STATE message
                                        // from closest node
        readyWait: numeric,             // seconds to wait for missing state
                                        // messages in JOIN phase
        repairTimeout: numeric,         // how long to wait for repair messages
        sendStateWaitAmount: numeric,   // how long to wait when sending state
                                        // tables delayed (should be very small)
        pingTimeout: numeric,           // how long to wait for PING reply
        pingRetries: numeric,           // how often to retry PING after
                                        // timeout
        useRegularNextHop: bool,
        alwaysSendUpdate: bool,
        coordBasedRouting: bool,        // use coord-based routing
        numCoordDigits: numeric,        // numbner of digits used for
                                        // coord-based routing
        CBRstartAtDigit: numeric,       // start at this digit using CBR 
        CBRstopAtDigit: numeric,        // stop at this digit using CBR

        //discoveryTimeoutAmount: numeric,   // how long to wait for leafset pings in discovery stage
        repairTaskTimeoutAmount: numeric,    // interval for periodic routing table maintenance
        leafsetMaintenanceTimeoutAmount: numeric, // leafset push/pull interval
        globalTuningTimeoutAmount: numeric;  // global tuning interval


    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
        in: direct_in;                  // gate for sendDirect
endsimple

//
// This module contains the routing table of the Pastry implementation.
//
// @author Felix Palmen
//
simple PastryRoutingTable
endsimple

//
// This module contains the leaf set of the Pastry implementation.
//
// @author Felix Palmen
//
simple PastryLeafSet
endsimple

//
// This module contains the neighborhood set of the Pastry implementation.
//
// @author Felix Palmen
//
simple PastryNeighborhoodSet
endsimple

//
// 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
//
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