Compound Module OverlayAccessRouter

Package: oversim.underlay.inetunderlay
File: src/underlay/inetunderlay/OverlayAccessRouter.ned

Access router that participates in the overlay

Author: Markus Mauch, Bernhard Heep

NotificationBoard InterfaceTable RoutingTable AccessNet ITier ITier ITier IOverlay UDP TCP NetworkLayer PPPInterface EthernetInterface NeighborCache BootstrapList CryptoModule

Usage diagram:

The following diagram shows usage relationships between types. Unresolved types are missing from the diagram. Click here to see the full picture.

Inheritance diagram:

The following diagram shows inheritance relationships for this type. Unresolved types are missing from the diagram. Click here to see the full picture.

Networks:

Name Type Description
InetUnderlayNetwork network

The InetUnderlay ned-file

See also: InetUnderlayConfigurator

Parameters:

Name Type Default value Description
routingFile string ""
overlayType string

overlay protocol compound module to use

tier1Type string

tier 1 application to use

tier2Type string

tier 2 module to use

tier3Type string

tier 3 module to use

numTiers int

number of tiers

Properties:

Name Value Description
node
display bgb=361,464

Gates:

Name Direction Size Description
pppg [ ] inout

gates from overlay

ethg [ ] inout

placeholder for zero-size vector

overlayNeighborArrowIn [ ] input

incoming gate for visualizing overlay neighborship with connection arrows

overlayNeighborArrowOut [ ] output

incoming gate for visualizing overlay neighborship with connection arrows

Unassigned submodule parameters:

Name Type Default value Description
accessNet.channelTypes string

list of (tx) channel types (from common/channels.ned)

accessNet.channelTypesRx string

list of (rx) channel types (from common/channels.ned)

accessNet.useIPv6Addresses bool false
tcp.advertisedWindow int 14*this.mss

in bytes, corresponds with the maximal receiver buffer capacity (Note: normally, NIC queues should be at least this size)

tcp.delayedAcksEnabled bool false

delayed ACK algorithm (RFC 1122) enabled/disabled

tcp.nagleEnabled bool true

Nagle's algorithm (RFC 896) enabled/disabled

tcp.limitedTransmitEnabled bool false

Limited Transmit algorithm (RFC 3042) enabled/disabled (can be used for TCPReno/TCPTahoe/TCPNewReno/TCPNoCongestionControl)

tcp.increasedIWEnabled bool false

Increased Initial Window (RFC 3390) enabled/disabled

tcp.sackSupport bool false

Selective Acknowledgment (RFC 2018, 2883, 3517) support (header option) (SACK will be enabled for a connection if both endpoints support it)

tcp.windowScalingSupport bool false

Window Scale (RFC 1323) support (header option) (WS will be enabled for a connection if both endpoints support it)

tcp.timestampSupport bool false

Timestamps (RFC 1323) support (header option) (TS will be enabled for a connection if both endpoints support it)

tcp.mss int 536

Maximum Segment Size (RFC 793) (header option)

tcp.tcpAlgorithmClass string "TCPReno"

TCPReno/TCPTahoe/TCPNewReno/TCPNoCongestionControl/DumbTCP

tcp.sendQueueClass string "TCPVirtualDataSendQueue"

TCPVirtualDataSendQueue/TCPMsgBasedSendQueue

tcp.receiveQueueClass string "TCPVirtualDataRcvQueue"

TCPVirtualDataRcvQueue/TCPMsgBasedRcvQueue

tcp.recordStats bool true

recording of seqNum etc. into output vectors enabled/disabled

networkLayer.ip.procDelay double 0s
networkLayer.arp.retryTimeout double 1s

number seconds ARP waits between retries to resolve an IP address

networkLayer.arp.retryCount int 3

number of times ARP will attempt to resolve an IP address

networkLayer.arp.cacheTimeout double 120s

number seconds unused entries in the cache will time out

ppp.ppp.mtu int 4470
eth.mac.promiscuous bool false

if true, all packets are received, otherwise only the ones with matching destination MAC address

eth.mac.address string "auto"

MAC address as hex string (12 hex digits), or "auto". "auto" values will be replaced by a generated MAC address in init stage 0.

eth.mac.txrate double 100Mbps

maximum data rate supported by this station (bit/s); actually chosen speed may be lower due to auto- configuration. 0 means fully auto-configured.

eth.mac.duplexEnabled bool true

whether duplex mode can be enabled or not; whether MAC will actually use duplex mode depends on the result of the auto-configuration process (duplex is only possible with DTE-to-DTE connection).

eth.mac.mtu int 1500
neighborCache.rpcUdpTimeout double

default timeout value for direct RPCs

neighborCache.rpcKeyTimeout double

default timeout value for routed RPCs

neighborCache.optimizeTimeouts bool

calculate timeouts from measured RTTs and network coordinates

neighborCache.rpcExponentialBackoff bool

if true, doubles the timeout for every retransmission

neighborCache.debugOutput bool

enable debug output

neighborCache.enableNeighborCache bool

use neighbor cache for reducing ping traffic?

neighborCache.rttExpirationTime double

expiration of the validity of the measured rtts

neighborCache.maxSize double

maximum size of the cache

neighborCache.rttHistory int
neighborCache.timeoutAccuracyLimit double
neighborCache.defaultQueryType string
neighborCache.defaultQueryTypeI string
neighborCache.defaultQueryTypeQ string
neighborCache.doDiscovery bool
neighborCache.collectClosestNodes int
neighborCache.ncsType string
neighborCache.useNcsForTimeout bool
neighborCache.ncsPiggybackOwnCoords bool
neighborCache.discoveryModeNumCloseNodes int

discovery mode settings

neighborCache.discoveryModeNumSpreadedNodes int
neighborCache.discoveryModeMaxSteps int
neighborCache.discoveryModeSpreadedSteps int
neighborCache.gnpDimensions int

gnp settings

neighborCache.gnpCoordCalcRuns int
neighborCache.gnpLandmarkTimeout double
neighborCache.npsMaxLayer int

nps settings

neighborCache.vivaldiShowPosition bool

vivaldi settings

neighborCache.vivaldiErrorConst double
neighborCache.vivaldiCoordConst double
neighborCache.vivaldiDimConst double
neighborCache.vivaldiEnableHeightVector bool
neighborCache.svivaldiLossConst double

svivaldi settings

neighborCache.svivaldiLossResetLimit double
neighborCache.simpleNcsDelayFaultType string

simpleNcs settings

neighborCache.treeMgmtEnableTreeManagement bool

Tree Management Settings

neighborCache.treeMgmtBuildInterval double

the interval to check the childNodeMap

neighborCache.treeMgmtChildrenTimeOut double

after this timeout an alive check ping is send

neighborCache.gvbEnableGlobalViewBuilder bool

Global View Builder Settings

neighborCache.gvbCoordSendInterval double

the interval to send the coordinates data

neighborCache.gvbOnlyAcceptCompleteCCD bool
neighborCache.gvbSendStrategy string

the send strategy to use. (sendAll|simplifyCoords|removeRandom|removeInaccurate|regions|treeTest)

neighborCache.gvbStrategyRemoveCoordsMode string

strategy mode (percentage|limitCoords|limitTraffic)

neighborCache.gvbStrategyRemoveCoordsPercentage int
neighborCache.gvbStrategyRemoveCoordsCoordsLimit int
neighborCache.gvbStrategyRemoveCoordsTrafficLimit int
neighborCache.gvbStrategyRegionsSizePerDimension int
neighborCache.gvbStrategyRegionsMaxSpread int
neighborCache.gvbStrategySimplifyCoordsFactor int
neighborCache.gvbC2AParameter string

parameterstring to append to c2a.rb call

neighborCache.gvbDistributeGlobalView bool

create areas and distribute the globalView to all nodes

bootstrapList.rpcUdpTimeout double

default timeout value for direct RPCs

bootstrapList.rpcKeyTimeout double

default timeout value for routed RPCs

bootstrapList.optimizeTimeouts bool

calculate timeouts from measured RTTs and network coordinates

bootstrapList.rpcExponentialBackoff bool

if true, doubles the timeout for every retransmission

bootstrapList.debugOutput bool

enable debug output

bootstrapList.mergeOverlayPartitions bool

if true, detect and merge overlay partitions

bootstrapList.maintainList bool

maintain a list of bootstrap candidates and check them periodically

cryptoModule.keyFile string

the name of the file containing the public key pair used to sign messages

Source code:

//
// Access router that participates in the overlay
//
// @author Markus Mauch, Bernhard Heep
//
module OverlayAccessRouter
{
    parameters:
        @node();
        string routingFile = default("");
        string overlayType; // overlay protocol compound module to use
        string tier1Type; // tier 1 application to use
        string tier2Type; // tier 2 module to use
        string tier3Type; // tier 3 module to use
        int numTiers; // number of tiers

        @display("bgb=361,464");
    gates:
        inout pppg[]; // gates from overlay
        inout ethg[]; // placeholder for zero-size vector
        input overlayNeighborArrowIn[]; // incoming gate for visualizing overlay neighborship with connection arrows
        output overlayNeighborArrowOut[]; // incoming gate for visualizing overlay neighborship with connection arrows

    submodules:
        notificationBoard: NotificationBoard {
            parameters:
                @display("p=76,192;i=block/control");
        }
        interfaceTable: InterfaceTable {
            parameters:
                @display("p=76,262;i=block/table");
        }
        routingTable: RoutingTable {
            parameters:
                IPForward = true;
                routerId = "auto";
                routingFile = routingFile;
                @display("p=76,340;i=block/table");
        }
        accessNet: AccessNet {
            parameters:
                @display("p=76,402");
        }
        tier3: <tier3Type> like ITier {
            parameters:
                @display("p=56,64;i=block/segm");
        }
        tier2: <tier2Type> like ITier {
            parameters:
                @display("p=139,88;i=block/segm");
        }
        tier1: <tier1Type> like ITier {
            parameters:
                @display("p=218,122;i=block/segm");
        }
        overlay: <overlayType> like IOverlay {
            parameters:
                @display("p=290,184;i=block/network2");
        }
        udp: UDP {
            parameters:
                @display("p=290,262;i=block/transport");
        }
        tcp: TCP {
            parameters:
                @display("p=230,262");
        }
        networkLayer: NetworkLayer {
            parameters:
                proxyARP = false;
                @display("p=290,340;i=block/fork;q=queue");
            gates:
                ifIn[sizeof(pppg)+sizeof(ethg)];
                ifOut[sizeof(pppg)+sizeof(ethg)];
        }
        ppp[sizeof(pppg)]: PPPInterface {
            parameters:
                @display("p=290,414,row,90;q=txQueue;i=block/ifcard");
        }
        eth[sizeof(ethg)]: EthernetInterface {
            parameters:
                @display("p=240,414,row,110;q=queue;i=block/ifcard");
        }
        neighborCache: NeighborCache {
            parameters:
                @display("p=168,262;i=block/table");
        }
        bootstrapList: BootstrapList {
            parameters:
                @display("p=168,340;i=block/table");
        }
        cryptoModule: CryptoModule {
            parameters:
                @display("p=168,402");
        }
    connections allowunconnected:
        tier1.to_lowerTier --> overlay.appIn if numTiers>0;
        tier1.from_lowerTier <-- overlay.appOut if numTiers>0;
        tier1.udpOut --> udp.appIn++ if numTiers>0;
        udp.appOut++ --> tier1.udpIn if numTiers>0;
        tier1.tcpOut --> tcp.appIn++ if numTiers>0;
        tcp.appOut++ --> tier1.tcpIn if numTiers>0;

        tier2.to_lowerTier --> tier1.from_upperTier if numTiers > 1;
        tier2.from_lowerTier <-- tier1.to_upperTier if numTiers > 1;
        tier2.udpOut --> udp.appIn++ if numTiers>1;
        udp.appOut++ --> tier2.udpIn if numTiers>1;
        tier2.tcpOut --> tcp.appIn++ if numTiers>1;
        tcp.appOut++ --> tier2.tcpIn if numTiers>1;

        tier3.to_lowerTier --> tier2.from_upperTier if numTiers > 2;
        tier3.from_lowerTier <-- tier2.to_upperTier if numTiers > 2;
        tier3.udpOut --> udp.appIn++ if numTiers>2;
        udp.appOut++ --> tier3.udpIn if numTiers>2;
        tier3.tcpOut --> tcp.appIn++ if numTiers>2;
        tcp.appOut++ --> tier3.tcpIn if numTiers>2;

        overlay.udpOut --> udp.appIn++;
        overlay.udpIn <-- udp.appOut++;

        overlay.tcpOut --> tcp.appIn++;
        overlay.tcpIn <-- tcp.appOut++;

        bootstrapList.udpOut --> udp.appIn++;
        bootstrapList.udpIn <-- udp.appOut++;

        udp.ipOut --> networkLayer.udpIn;
        udp.ipIn <-- networkLayer.udpOut;

        tcp.ipOut --> networkLayer.tcpIn;
        tcp.ipIn <-- networkLayer.tcpOut;

        // connections to network outside
        for i=0..sizeof(pppg)-1 {
            pppg[i] <--> ppp[i].phys;
            ppp[i].netwOut --> networkLayer.ifIn[i];
            ppp[i].netwIn <-- networkLayer.ifOut[i];
        }

        for i=0..sizeof(ethg)-1 {
            ethg[i] <--> eth[i].phys;
            eth[i].netwOut --> networkLayer.ifIn[sizeof(pppg)+i];
            eth[i].netwIn <-- networkLayer.ifOut[sizeof(pppg)+i];
        }
}