- Facts:
- A node that
is member of the
logical ring can
invite
a non-member node
to join
the logical ring
(and become
part of the
token bus network)
- Each member node of
the token bus network
has a timer
- When the timer
expires:
- The node will send an invite message to invite a range of nodes to join
- Each member node of
the token bus network
has a timer
- A node that
is member of the
logical ring can
invite
a non-member node
to join
the logical ring
(and become
part of the
token bus network)
- Simplifying assumption:
- To simplify the
discussion on
node insertion,
we assume that:
- There is exactly one node that wants to join the token bus network
- To simplify the
discussion on
node insertion,
we assume that:
- The Insertion
protocol
(with example):
- Invitation step:
- A node X
that is
not the
last node
will
send the following
control frame to
invite non-members to
join:
X.Solicit_successor1( X.succ ) will invite nodes in range (X .. X.succ) to join
- The
last
node L
will
send the following
control frame to
invite non-members to
join:
L.Solicit_successor2( L.succ ) will invite nodes in ranges (∞ .. L.succ) and (L .. 0) to join
Example:
- Current nodes in
logical ring:
+--> 4 --> 1 --> 0 --+ (4 is token holder) | | +-----------------------+Node 4 sends out an invitation using Solicit_successor1( 1 ) :
- A node X
that is
not the
last node
will
send the following
control frame to
invite non-members to
join:
- Node insertion step
(or node joining step):
- The joining node will:
-
Update
its Predecessor
variable to
the inviter's successor
(= X.succ)
- Send the Set_successor( own_ID ) message to the inviter node
-
Update
its Predecessor
variable to
the inviter's successor
(= X.succ)
- When the invitor node
receives the
Set_successor(joining_ID)
message, the
invitor node will:
-
Update
its Successor
variable to
the joining node ID
- Send the Set_successor(invitorSucc) to its new successor
-
Update
its Successor
variable to
the joining node ID
Example: Suppose node 2 joins (i.e.: node 2 is the joining node)
- Node 2
updates
its variable
predecessor = 4:
- Node 2 then
sends
the message
Set_successor( 2 )
to node 4:
- Node 4 will
update its
Successor = 2:
- Node 4
will send the
"4.Set_successor(1)"
message its
new successor (node 2):
Note:
- The logical ring is
still
not complete:
Node 2 must still set its successor to node 1
Node 1 must update its predecessor to node 2- Processing the 4.Set_successor(1) message will complete these updates !!!
- The logical ring is
still
not complete:
- The joining node will:
- Completion step:
- When the joining node receives
the Set_succesor( ) frame:
- The joining node set
its succesor
= invitor node ID
- Then joining node
sends a
token to its
new successor node
- When its new successor node
receives the
token,
it will
update its
successor
- The logical ring is then complete !!!
- The joining node set
its succesor
= invitor node ID
Example: continued with the above...
- Node 2
received the
4.Set_successor(
1 )
message and
updates its
successor variable:
- Node 2 then
sends (= passes) the token
(in 2.Token( )
message) to its
successor:
- When node 1 has
received the token
(in 2.Token( )
message),
node 2 will
update its
predecessor:
(Because only your predecessor can pass a token to you !!!)
- When the joining node receives
the Set_succesor( ) frame:
- Invitation step:
- There are 2 special cases
that the node insertion protocol
must handle:
- There are no (= zero) nodes
that wish
to join the
token bus network
- There are more than 1 node that wish to join the token bus network
- There are no (= zero) nodes
that wish
to join the
token bus network
- Fact:
- When there are
no nodes that
wish to join
the token bus network:
- There will be no reply for the Solicit_successor(1 or 2) message !!!
- When there are
no nodes that
wish to join
the token bus network:
- Solution:
- The invitor node
sets
a time out
- When no reply is
received before
time runs out:
- The invitor node
simply
passes the
token to
its current successor
(Because no new node wants to be its successor !!!)
- The invitor node
simply
passes the
token to
its current successor
- The invitor node
sets
a time out
- Recall:
- The X.Solicit_successor(1 or 2)(Y)
message will
invite
a
range of nodes
to join the
logical ring
- It is possible for multiple nodes to join (= send control messages) at the same time !!!
- The X.Solicit_successor(1 or 2)(Y)
message will
invite
a
range of nodes
to join the
logical ring
- The Node insertion protocol
of the
token bus:
the
multiple reply case
- If multiple nodes
try to join the
token bus network, then:
- Their control messages will result in a collision on the token bus
Example:
- Node 4 sends
Solicit_successor
control frame:
Nodes 2 and 3 are invited to join !!!
- When both
node 2 and 3 tries
to join
(by sending
a Set_successor( ) message):
- If multiple nodes
try to join the
token bus network, then:
- The transmitting nodes will
detect the collision and
then
execute:
- A
collision resolution
protocol
to:
- Select a "winner" among the colliding nodes
- The winner will then execute the insertion protocol (discussed above)
We will discuss the collision resolution protocl in the next webpage
- A
collision resolution
protocol
to:
- Comment:
- The last node
will send the second type of
Solicitation message:
Solicit_successor2( )
Example: last node 3 sends "3.Solicit_successor2(7) "
The 3.Solicit_successor2( 7 ) message will invite the following nodes to join the token bus:
Nodes 1, 2 (with id < 3) and node 8 (with id > 7) are invited
Furthermore:
- The insertion protocol used is identical to the insertion protocol used for Solicit_successor1( ) described above...
- The last node
will send the second type of
Solicitation message: