Compound Module OverlayQuon

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

(no description)

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	Description
udpIn	input	gate from the UDP layer
udpOut	output	gate to the UDP layer
tcpIn	input	gate from the TCP layer
tcpOut	output	gate to the TCP layer
appIn	input	gate from the application
appOut	output	gate to the application

Unassigned submodule parameters:

Name	Type	Description
quon.rpcUdpTimeout	double	default timeout value for direct RPCs
quon.rpcKeyTimeout	double	default timeout value for routed RPCs
quon.optimizeTimeouts	bool	calculate timeouts from measured RTTs and network coordinates
quon.rpcExponentialBackoff	bool	if true, doubles the timeout for every retransmission
quon.localPort	int	UDP port for overlay messages
quon.overlayId	int	identifies the overlay this node belongs to (used for multiple overlays)
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.lookupVerifySiblings	bool	true, if siblings need to be authenticated with a ping
quon.lookupMajoritySiblings	bool	true, if sibling candidates are selected by a majority decision if using parallel paths
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.lookupAcceptLateSiblings	bool	if true, a FindNodeResponse with sibling flag set is always accepted, even if it is from a previous lookup step
quon.routingType	string	default routing mode (iterative, semi-recursive,...)
quon.rejoinOnFailure	bool	rejoin after loosing connection to the overlay?
quon.sendRpcResponseToLastHop	bool	needed by KBR protocols for NAT support
quon.recordRoute	bool	record visited hops on route
quon.dropFindNodeAttack	bool	if node is malicious, it tries a findNode attack
quon.isSiblingAttack	bool	if node is malicious, it tries a isSibling attack
quon.invalidNodesAttack	bool	if node is malicious, it tries a invalidNode attack
quon.dropRouteMessageAttack	bool	if node is malicious, it drops all received BaseRouteMessages
quon.measureAuthBlock	bool	if true, measure the overhead of signatures in rpc messages
quon.restoreContext	bool	if true, a node rejoins with its old nodeId and malicious state
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.numBackups	int	the number of binding beackups per quadrant
quon.cacheInterval	int	interval to cache position in login cache
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.AOIBuffer	double	increase AOI by fixed amount
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.addJoinDelay	double
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
quon.newNeighborsOnlyBinding	bool	notify only binding and softstate neighbors over new neighbors

Source code:

module OverlayQuon like IOverlay
{
    gates:
        input udpIn; // gate from the UDP layer
        output udpOut; // gate to the UDP layer
        input tcpIn;    // gate from the TCP layer
        output tcpOut;    // gate to the TCP 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;
}