Compound Module OverlayQuon

Package: oversim.overlay.quon
File: src/overlay/quon/Quon.ned

(no description)

Quon

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.

Gates:

Name Direction Size Description
udpIn input

gate from the UDP layer

udpOut output

gate to the UDP layer

appIn input

gate from the application

appOut output

gate to the application

Unassigned submodule parameters:

Name Type Default value Description
quon.rpcUdpTimeout double

default timeout value for direct RPCs

quon.rpcKeyTimeout double

default timeout value for routed RPCs

quon.rpcExponentialBackoff bool

if true, doubles the timeout for every retransmission

quon.localPort int

UDP port for Chord messages

quon.debugOutput bool

enable debug output

quon.keyLength int

overlay key length in bits

quon.nodeId string

optional nodeId as string in hexadecimal notation

quon.useCommonAPIforward bool

enable CommonAPI forward() calls

quon.drawOverlayTopology bool

draw arrow to successor node?

quon.hopCountMax int

maximum number of overlay hops

quon.recNumRedundantNodes int

numRedundantNodes for recursive routing

quon.joinOnApplicationRequest bool

only join the overlay on application request

quon.collectPerHopDelay bool

delay statistics for single hops

quon.routeMsgAcks bool

use RPCs for route messages

quon.lookupRedundantNodes int

number of next hops in each step

quon.lookupParallelPaths int

number of parallel paths

quon.lookupParallelRpcs int

number of nodes to ask in parallel

quon.lookupSecure bool

true, if all nodes should be identified with a ping

quon.lookupMerge bool

true, if parallel Rpc results should be merged

quon.lookupFailedNodeRpcs bool

communicate failed nodes

quon.lookupStrictParallelRpcs bool

limited the number of concurrent rpcs to parameter parallelRpcs

quon.lookupUseAllParallelResponses bool

merge all parallel responses from earlier steps

quon.lookupNewRpcOnEveryTimeout bool

send a new RPC immediately after an RPC timeouts

quon.lookupNewRpcOnEveryResponse bool

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

quon.lookupFinishOnFirstUnchanged bool

finish lookup, if the last pending RPC returned without progress

quon.lookupVisitOnlyOnce bool

if true, the same node is never asked twice during a single lookup

quon.routingType string

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

quon.rejoinOnFailure bool

rejoin after loosing connection to the overlay?

quon.recordRoute bool

record visited hops on route

quon.areaDimension double

movement range from [0.0, 0.0] to [areaDimension, areaDimension]

quon.joinTimeout double

retry join timeout in seconds

quon.deleteTimeout double

delete dead/offline neighbors from list of known neighbors after # seconds

quon.aliveTimeout double

ping neighbor status in seconds

quon.contactBackupIntervall double

contact backup neighbors every # seconds

quon.connectionLimit double

maximum # of neighbor connections (for use with dynamic AOI)

quon.minAOIWidth double

minimum area of interest size (for use with dynamic AOI)

quon.AOIWidth double

this nodes area of interest (maximum area of interest when dynamic AOI is used)

quon.AOIBufferFactor double

increase AOI by factor

quon.AOIAdaptionIntervall double

adaption rate for dynamic AOI changes

quon.AOIAdaptionSensitivity double

how much the AOI can be adapted in one step (for use with dynamic AOI) (max=1)

quon.AOIGossipSensitivity double

how much the AOI adaption can be influenced by neighbors (for use with dynamic AOI) (max=1)

quon.AOIAdaptLinear bool

use linear AOI adaption? (for use with dynamic AOI)

quon.useSquareMetric bool

use max(|a.x - b.x|, |a.y - b.y|) as distance metric instead of euclidean distance

Source code:

module OverlayQuon like IOverlay
{
    gates:
        input udpIn; // gate from the UDP layer
        output udpOut; // gate to the UDP layer
        input appIn; // gate from the application
        output appOut; // gate to the application

    submodules:
        quon: Quon {
            parameters:
                @display("p=60,60");

        }
    connections allowunconnected:
        udpIn --> quon.udpIn;
        udpOut <-- quon.udpOut;
        appIn --> quon.appIn;
        appOut <-- quon.appOut;
}