Subject: [Roll] Remove 'T' flag?

From: Tim Winter <[email-masked]>
Date: Thu, 17 Jun 2010 23:14:42 -0400

Consider the case if we clarify Section 8.5 'Triggering DAO Messages' to add the 
following rule for RPL-10:

        In non-storing mode, if a node hears one of its DAO parents
        increment its DTSN, the node MUST increment its own DTSN.

Then,

1) In storing mode operation, a node can increment its own DTSN to get refreshed DAO 
messages from its one-hop children.

3) In non-storing mode operation, a DODAG Root can increment its own DTSN to cause 
all non-storing nodes in the sub-DODAG to increment their DTSNs in turn, and get 
refreshed DAO messages from all its children.

The 'T' flag, if it remained, would seem to only be useful for a node to 'pull' all 
DAOs from its sub-DODAG in storing mode operation.  (This is in addition to the 
mechanisms provided by DTSN and DAO-ACK which can assist a parent to reliably get 
DAOs from its children.)

Is this necessary?  Now that we are only supporting storing and non-storing modes of 
operation, would you support to remove the 'T' flag?

Regards,

-Tim

---

From: JP Vasseur <[email-masked]>
Date: Fri, 18 Jun 2010 08:28:02 +0200

On Jun 18, 2010, at 5:14 AM, Tim Winter wrote:

>
> Consider the case if we clarify Section 8.5 'Triggering DAO  
> Messages' to add the following rule for RPL-10:
>
> 1) In storing mode operation, a node can increment its own DTSN to  
> get refreshed DAO messages from its one-hop children.
>
> 3) In non-storing mode operation, a DODAG Root can increment its own  
> DTSN to cause all non-storing nodes in the sub-DODAG to increment  
> their DTSNs in turn, and get refreshed DAO messages from all its  
> children.
>
> The 'T' flag, if it remained, would seem to only be useful for a  
> node to 'pull' all DAOs from its sub-DODAG in storing mode  
> operation.  (This is in addition to the mechanisms provided by DTSN  
> and DAO-ACK which can assist a parent to reliably get DAOs from its  
> children.)
>
> Is this necessary?  Now that we are only supporting storing and non- 
> storing modes of operation, would you support to remove the 'T' flag?

Yes, this would be redundant with 1).

Cheers.

JP.

>
> Regards,
>
> -Tim
> _______________________________________________
> Roll mailing list
> [email-masked]
> https://www.ietf.org/mailman/listinfo/roll

---

From: "Mathilde Durvy (mdurvy)" <[email-masked]>
Date: Fri, 18 Jun 2010 11:32:40 +0200

Hi Tim, 

We just had a similar discussion with Phil, Pascal, and Richard last week
(see thread "leaf node and DTSN").
We reach the same conclusion as you. Please see my comments below.
Best,
Mathilde 

----------

Consider the case if we clarify Section 8.5 'Triggering DAO Messages' to add
the 
following rule for RPL-10:

Then,

1) In storing mode operation, a node can increment its own DTSN to get
refreshed DAO 
messages from its one-hop children.

3) In non-storing mode operation, a DODAG Root can increment its own DTSN to
cause 
all non-storing nodes in the sub-DODAG to increment their DTSNs in turn, and
get 
refreshed DAO messages from all its children.

The 'T' flag, if it remained, would seem to only be useful for a node to
'pull' all 
DAOs from its sub-DODAG in storing mode operation.  (This is in addition to
the 
mechanisms provided by DTSN and DAO-ACK which can assist a parent to
reliably get 
DAOs from its children.)
[Mathilde] Actually, not any node just the root of the DODAG  (according to
the DIO base rules the "T" flag should not be modified by other nodes).
Hence the 'T' flag is only useful for the root to ask for a global DAO
refresh. Hence the question is whether removing this possibility of a global
DAO refresh in the non-storing mode is ok. In my opinion it is.

Is this necessary?  Now that we are only supporting storing and non-storing
modes of 
operation, would you support to remove the 'T' flag?
[Mathilde] yes. Maybe it's even worth to ask the question whether we could
remove the DTSN and keep the T flag saving more bits. The question is: now
that we have DAO-ACKs do we still need a multiple bit DTSN?

---

From: Philip Levis <[email-masked]>
Date: Fri, 18 Jun 2010 10:27:04 -0700

On Jun 17, 2010, at 11:28 PM, JP Vasseur wrote:

>> Consider the case if we clarify Section 8.5 'Triggering DAO Messages' to add the following rule for RPL-10:
>> 
>> 1) In storing mode operation, a node can increment its own DTSN to get refreshed DAO messages from its one-hop children.
>> 
>> 3) In non-storing mode operation, a DODAG Root can increment its own DTSN to cause all non-storing nodes in the sub-DODAG to increment their DTSNs in turn, and get refreshed DAO messages from all its children.
>> 
>> The 'T' flag, if it remained, would seem to only be useful for a node to 'pull' all DAOs from its sub-DODAG in storing mode operation.  (This is in addition to the mechanisms provided by DTSN and DAO-ACK which can assist a parent to reliably get DAOs from its children.)
>> 
>> Is this necessary?  Now that we are only supporting storing and non-storing modes of operation, would you support to remove the 'T' flag?
> 

Let me reverse the discussion to make sure we covering the issues: is it important, in a non-storing network, for a node can trigger DAOs from just its children? Currently that's impossible. So there are two cases:

storing, non-storing

and two operations:

pull from children, pull from sub-DODAG

Which elements of this table are needed?

Phil

---

From: JP Vasseur <[email-masked]>
Date: Fri, 18 Jun 2010 20:03:47 +0200

On Jun 18, 2010, at 7:27 PM, Philip Levis wrote:

>>> 3) In non-storing mode operation, a DODAG Root can increment its  
>>> own DTSN to cause all non-storing nodes in the sub-DODAG to  
>>> increment their DTSNs in turn, and get refreshed DAO messages from  
>>> all its children.
>>>
>>> operation.  (This is in addition to the mechanisms provided by  
>>> DTSN and DAO-ACK which can assist a parent to reliably get DAOs  
>>> from its children.)
>>>
>>> Is this necessary?  Now that we are only supporting storing and  
>>> non-storing modes of operation, would you support to remove the  
>>> 'T' flag?
>>
> Let me reverse the discussion to make sure we covering the issues:  
> is it important, in a non-storing network, for a node can trigger  
> DAOs from just its children?

but in the non storing case, do you think that an intermediate node (a  
non DAG root) needs to get a refresh DAO from its children ?

> Currently that's impossible. So there are two cases:
>
> storing, non-storing
>
> and two operations:
>

---

From: Tim Winter <[email-masked]>
Date: Sun, 20 Jun 2010 19:17:43 -0400

> Which elements of this table are needed?

My take:

(storing, pull from children) -- required, this is a necessary part of how storing 
nodes will maintain state.

(storing, pull from sub-DODAG) -- not required, state will percolate up from the 
sub-DODAG

(non-storing, pull from children) -- seems not required, what would be the use case 
where this is needed?  I defer however to those with more expertise in operating the 
non-storing case.

(non-storing, pull from sub-DODAG) -- seems useful for a root in the non-storing case 
to be able to refresh DAO information without incrementing the DODAGVersionNumber and 
triggering a global repair.  Doesn't seem useful for non-root nodes.  Again, I would 
defer to those with more expertise in operating non-storing networks.

Regards,

-Tim

---

From: Tim Winter <[email-masked]>
Date: Sun, 20 Jun 2010 19:18:18 -0400

Hi Mathilde,

> We reach the same conclusion as you. Please see my comments below.

Agreed.

> that we have DAO-ACKs do we still need a multiple bit DTSN?

My opinion is that the DTSN is more useful than the 'T' flag.  The DTSN in a sense is 
a reliable mechanism to request DAOs, while DAO-ACKs serve as part of a reliable 
mechanism to deliver the DAOs.  (Also keep in mind that DAO-ACKs may not be present 
in every implementation.)

Consider the case when only the 'T' flag is present:  How long / for how many DIOs 
should the parent assert the 'T' flag?  How many times should a child respond to that 
request, even if it has just responded to the asserted 'T' flag in the prior DIO? How 
occasionally/periodically should the parent assert the 'T' flag to pull a DAO from a 
child?

The DTSN, on the other hand, allows the trigger for sending DAO's to be reliably 
asserted, at the expense of a multiple bit field present in every DIO and some state 
in the child.  Each child, especially in the case where DAO-ACK is used, need only 
reply once to each DTSN increment.  A child who misses the initial increment can 
easily observe in a later DIO that an increment has occurred and respond.

What do others think?

-Tim

---

From: Richard Kelsey <[email-masked]>
Date: Mon, 21 Jun 2010 10:54:28 -0400

> Date: Sun, 20 Jun 2010 19:17:43 -0400
> From: Tim Winter <[email-masked]>
> 
> My take:
> 
> (storing, pull from children) -- required, this is a
> necessary part of how storing nodes will maintain state.
> 
> (storing, pull from sub-DODAG) -- not required, state will
> percolate up from the sub-DODAG
> 
> (non-storing, pull from children) -- seems not required,
> what would be the use case where this is needed?  I defer
> however to those with more expertise in operating the
> non-storing case.
> 
> (non-storing, pull from sub-DODAG) -- seems useful for a
> root in the non-storing case to be able to refresh DAO
> information without incrementing the DODAGVersionNumber
> and triggering a global repair.  Doesn't seem useful for
> non-root nodes.  Again, I would defer to those with more
> expertise in operating non-storing networks.

I agree with Tim's analysis and am in favor of removing
the 'T' flag.
                           -Richard Kelsey

---

From: Philip Levis <[email-masked]>
Date: Mon, 21 Jun 2010 08:12:44 -0700

On Jun 20, 2010, at 4:18 PM, Tim Winter wrote:

> Hi Mathilde,
> 
> My opinion is that the DTSN is more useful than the 'T' flag.  The DTSN in a sense is a reliable mechanism to request DAOs, while DAO-ACKs serve as part of a reliable mechanism to deliver the DAOs.  (Also keep in mind that DAO-ACKs may not be present in every implementation.)
> 
> Consider the case when only the 'T' flag is present:  How long / for how many DIOs should the parent assert the 'T' flag?  How many times should a child respond to that request, even if it has just responded to the asserted 'T' flag in the prior DIO? How occasionally/periodically should the parent assert the 'T' flag to pull a DAO from a child?
> 
> The DTSN, on the other hand, allows the trigger for sending DAO's to be reliably asserted, at the expense of a multiple bit field present in every DIO and some state in the child.  Each child, especially in the case where DAO-ACK is used, need only reply once to each DTSN increment.  A child who misses the initial increment can easily observe in a later DIO that an increment has occurred and respond.
> 
> What do others think?

Tim,

I agree -- DTSN is a superior mechanism to the 'T' flag, and the 'T' flag is superfluous. 

Phil

---

From: Philip Levis <[email-masked]>
Date: Mon, 21 Jun 2010 19:57:59 -0700

On Jun 20, 2010, at 4:17 PM, Tim Winter wrote:

> 
> My take:
> 
> (storing, pull from children) -- required, this is a necessary part of how storing nodes will maintain state.
> 
> (storing, pull from sub-DODAG) -- not required, state will percolate up from the sub-DODAG

So if the network is in storing mode, a DTSN increment pulls from children.

> 
> (non-storing, pull from children) -- seems not required, what would be the use case where this is needed?  I defer however to those with more expertise in operating the non-storing case.
> 
> (non-storing, pull from sub-DODAG) -- seems useful for a root in the non-storing case to be able to refresh DAO information without incrementing the DODAGVersionNumber and triggering a global repair.  Doesn't seem useful for non-root nodes.  Again, I would defer to those with more expertise in operating non-storing networks.

This is the open question: we only get one of the two. I agree that pulling from a sub-DODAG is useful, e.g., if a DAO was lost. The issue, though, is that you don't know where to pull. E.g., node A was a DAO child of B, link AB fails, it is now a child of C. A sends a DAO to the DODAG Root announcing its DODAG parents. That DAO is lost. How do you know to trigger a DAO at C?

Based on this, it seems like we want the latter case: a way to refresh DAOs without rebuilding the upward routes.

Phil

---

From: Richard Kelsey <[email-masked]>
Date: Tue, 22 Jun 2010 12:24:37 -0400

> From: Philip Levis <[email-masked]>
> Date: Mon, 21 Jun 2010 19:57:59 -0700
> 
> > (non-storing, pull from children) -- seems not required, what would
> > be the use case where this is needed?  I defer however to those with
> > more expertise in operating the non-storing case.
> >
> > (non-storing, pull from sub-DODAG) -- seems useful for a root in
> > the non-storing case to be able to refresh DAO information without
> > incrementing the DODAGVersionNumber and triggering a global repair.
> > Doesn't seem useful for non-root nodes.  Again, I would defer to
> > those with more expertise in operating non-storing networks.
> 
> This is the open question: we only get one of the two. I agree that
> pulling from a sub-DODAG is useful, e.g., if a DAO was lost. The
> issue, though, is that you don't know where to pull. E.g., node A was
> a DAO child of B, link AB fails, it is now a child of C. A sends a DAO
> to the DODAG Root announcing its DODAG parents. That DAO is lost. How
> do you know to trigger a DAO at C?

You don't.  For non-storing networks you really need to use
DAO-acks because of this problem.  The 'T' flag doesn't
help.

In non-storing networks the root can use the DTSN to pull
refresh its DAO information if it becomes stale or lost for
any reason.  DAO losses within the DODAG need to be handled
by DAO-acks and resends.

                              -Richard Kelsey

---

From: JP Vasseur <[email-masked]>
Date: Wed, 23 Jun 2010 14:51:14 +0200

+1

On Jun 21, 2010, at 5:12 PM, Philip Levis wrote:

>> My opinion is that the DTSN is more useful than the 'T' flag.  The  
>> DTSN in a sense is a reliable mechanism to request DAOs, while DAO- 
>> ACKs serve as part of a reliable mechanism to deliver the DAOs.   
>> (Also keep in mind that DAO-ACKs may not be present in every  
>> implementation.)
>>
>> Consider the case when only the 'T' flag is present:  How long /  
>> for how many DIOs should the parent assert the 'T' flag?  How many  
>> times should a child respond to that request, even if it has just  
>> responded to the asserted 'T' flag in the prior DIO? How  
>> occasionally/periodically should the parent assert the 'T' flag to  
>> pull a DAO from a child?
>>
>> The DTSN, on the other hand, allows the trigger for sending DAO's  
>> to be reliably asserted, at the expense of a multiple bit field  
>> present in every DIO and some state in the child.  Each child,  
>> especially in the case where DAO-ACK is used, need only reply once  
>> to each DTSN increment.  A child who misses the initial increment  
>> can easily observe in a later DIO that an increment has occurred  
>> and respond.
>>
>> What do others think?
>
> Tim,
>

---

From: JP Vasseur <[email-masked]>
Date: Wed, 23 Jun 2010 16:30:05 +0200

> any reason.  DAO losses within the DODAG need to be handled

Agree.

JP.