mirror of
https://github.com/ChronosX88/netsukuku.git
synced 2024-12-23 01:11:47 +00:00
158 lines
5.0 KiB
Plaintext
158 lines
5.0 KiB
Plaintext
- QSPN scalability
|
|
|
|
The QSPN is an optimised way of "sending a tracer_pkt from each extreme node".
|
|
A tracer_pkt is just a flood, and the total number of floods is given by:
|
|
|
|
total_floods = extreme_nodes + 1
|
|
|
|
where the extreme_nodes are:
|
|
|
|
extreme_nodes = number_of_nodes_with_only_one_link + number_of_cycles*2
|
|
|
|
A cycle here is meant as a set of nodes, where each node is linked at least at
|
|
two other nodes of the set.
|
|
|
|
The total different packets generated by a single flood is equal to:
|
|
|
|
total_packets_per_flood = Sum( number_of_links_of_each_node - 1 ) + 1
|
|
|
|
Since the network is organized in gnodes, the total_floods for all the levels
|
|
will be the sum of the total_floods of each level. The same applies to the
|
|
total_packets_per_flood.
|
|
|
|
|
|
Now we'll consider various worst scenarios.
|
|
|
|
|
|
- First scenario
|
|
|
|
The first worst case is a network where all the nodes are an extreme_node, i.e.
|
|
there's one node X and all the other are linked to it by just one link.
|
|
|
|
O Y
|
|
\ /
|
|
\ /
|
|
N ---- X ----L
|
|
|
|
|
|
|
|
M (A graph describing the first worst
|
|
scenario)
|
|
|
|
In this case all the nodes, including X, will send a tracer_pkt.
|
|
This means that if all the nodes in the level 0 are linked in that way, and all
|
|
the gnodes of the higher levels are also linked between them in the same way,
|
|
then the total floods, in all the levels, we'll be:
|
|
|
|
total_floods = MAXGROUPNODE * levels
|
|
|
|
Where MAXGROUPNODE is the number of (g)node present in a gnode.
|
|
By the way, this configuration has its advantages because there is only one
|
|
hop between each node, therefore each flood will end after one hop and the
|
|
total packets will be:
|
|
|
|
total_packets = MAXGROUPNODE^2 * levels
|
|
|
|
MAXGROUPNODE is equal to 256.
|
|
In the ipv4 we have 4 levels.
|
|
This means that in a network composed by 2^32 nodes, in the first worst
|
|
scenario to run the QSPN at all the levels will have:
|
|
|
|
total_floods = 1024; total_packets = 262144;
|
|
|
|
Note that "levels" is equal to log_2(N)/MAXGROUPNODE_BITS, where N is the
|
|
maximum number of nodes in the network and MAXGROUPNODE_BITS is equal to 8.
|
|
MAXGROUPNODE is also equal to 2^MAXGROUPNODE_BITS.
|
|
The final formulas that describes the growth of the number of floods and
|
|
packets are:
|
|
|
|
total_floods = 2^5 * log_2(N)
|
|
|
|
total_packets = 2^13 * log_2(N)
|
|
|
|
|
|
- Second scenario
|
|
|
|
In this case we consider a network where each (g)node is linked to all the other
|
|
(g)nodes.
|
|
C
|
|
/|\
|
|
/ | \
|
|
A-----D
|
|
\ | /
|
|
\|/
|
|
E
|
|
|
|
That means that we have 1 cycle and 0 nodes_with_only_one_link, so the
|
|
total_floods are:
|
|
|
|
total_floods = 2
|
|
|
|
Since every (g)node is linked with every other (g)gnodes, the number of links
|
|
for each of them is MAXGROUPNODE and the number of total different packets
|
|
generated per flood is:
|
|
|
|
total_packets = ( ( MAXGROUPNODE - 1 ) * MAXGROUPNODE + 1)
|
|
|
|
Supposing that this configuration is the same for the upper levels too, we have:
|
|
|
|
total_floods = 2 * levels
|
|
total_packets = total_floods * ( ( MAXGROUPNODE - 1 ) * MAXGROUPNODE + 1)
|
|
|
|
N = total_number_of_nodes_in_the_network
|
|
levels = log_2(N)/MAXGROUPNODE_BITS
|
|
|
|
total_packets = (log_2(N)/4) * ( ( MAXGROUPNODE - 1 ) * MAXGROUPNODE + 1)
|
|
|
|
In ipv4, with 2^32 nodes:
|
|
|
|
total_packets = 522248
|
|
|
|
- Third scenario
|
|
|
|
All the (g)nodes are in just one line: to reach the end node B from the start
|
|
node A we have traverse N nodes, with N equal to the total number of nodes
|
|
minus 2.
|
|
|
|
In this awful case a flood will have to traverse N hops, this means that if
|
|
the average rtt between two nodes is 70ms, then the flood, if started from an
|
|
extreme node will take about 9 years to reach the other end.
|
|
|
|
- About the maximum size of a tracer_pkt
|
|
|
|
Each time a tracer_pkt traverse a node it grows of one byte, since the
|
|
tracer_pkt is always restricted to a determinate level, which has maximum
|
|
MAXGROUPNODE nodes, the maximum size of a plain tracer_pkt is 256 Bytes (we
|
|
are not counting the headers, which are a constant size).
|
|
|
|
The things change if the tracer_pkt traverses border nodes, in fact,
|
|
(7 + 10*L) bytes are added in the the tracer_pkt each time it passes trough a
|
|
bnode. L is the number of gnodes the border node is linked to.
|
|
|
|
- About the maximum size of the maps
|
|
|
|
The size of levels in the maps is fixed 'cause we already know the maximum number
|
|
of nodes in the network. We are also considering that we store only the 20
|
|
best routes for each node.
|
|
|
|
So the maximum size of the maps, when we have all the routes stored, and the
|
|
bnode with all their maximum links filled is:
|
|
|
|
internal map | external map | border node map
|
|
|
|
ipv4 44032 | 136704 | 3159552
|
|
|
|
ipv6 44032 | 683520 | 15797760
|
|
|
|
(in bytes).
|
|
|
|
The bnode map is so large because we are considering the worst case in which
|
|
in each of our gnodes there are 256 bnodes each of them is linked to 512
|
|
gnodes.
|
|
|
|
|
|
- About the overload created by multiple hooks of (g)nodes
|
|
|
|
In order to prevent that a QSPN is sent every time a (g)node joins the network
|
|
the QSPN are all syncronised in each level, therefore the maps are updated at
|
|
each qspn_round. (Read the section "5.1.4 Qspn round").
|