Subject: [Rift] Today's core meeting ...

From: Tony Przygienda <[email-masked]>
Date: Thu, 24 Jan 2019 10:28:09 -0800

We had a meeting last week but I forgot to upload ... we talked v4/v6 dual
AF support & bandwidth load balancing north/south ...

Today's meeting synopsis was in depth dive on intended TIDE changes
compared to ISIS CSNP (which Bruno was pushing on a while ago already) to
scale flooding up further and hackathon Prague scope ...

upload:

https://www.dropbox.com/sh/z72t8ae85inl8we/AAAbsfXIQ-_j-N3SWVD0Cr_Fa?dl=0

--- tony

---

From: "Pascal Thubert (pthubert)" <[email-masked]>
Date: Thu, 31 Jan 2019 09:35:17 +0000

Hello Tony

Sorry I missed the call last week. I should have notified. I was giving a course on RPL.
I’m looking at the recording (huge thanks for doing that!).

Around T=16:00 you are discussing the boundaries of a TIDE, where it starts and where it stops, whether C should be repeated.
My recommendation would be:

  *   Define 0 and infinity. 0 may be present, infinity cannot.
  *   In the start indicate the first that’s in (that’s A)
  *   In the end indicate the first that in not in (that’s D)
  *   Then place descriptors A, B and C

This avoids repeating C and does not leave a hole. The caveat is that you must dup your TIDEs without an interruption that would insert C’ between the moment you send TIDE [A, D[ and the moment you send TIDE [D, G[.

Works?

Pascal

From: RIFT <[email-masked]> On Behalf Of Tony Przygienda
Sent: jeudi 24 janvier 2019 19:28
To: [email-masked]
Subject: [Rift] Today's core meeting ...

We had a meeting last week but I forgot to upload ... we talked v4/v6 dual AF support & bandwidth load balancing north/south ...

Today's meeting synopsis was in depth dive on intended TIDE changes compared to ISIS CSNP (which Bruno was pushing on a while ago already) to scale flooding up further and hackathon Prague scope ...

upload:

--- tony

---

From: "Pascal Thubert (pthubert)" <[email-masked]>
Date: Thu, 31 Jan 2019 10:02:16 +0000

Follow up:

Around minute 28 you are discussing with Bruno about resending the all database when the adjacency comes up, though you and Bruno dislike the idea.
If you agree with the proposal below, then the following operation could happen:

  *   When the adjacency comes up, child starts blasting its TIDEs, no new “sequence counter”
  *   Say that child sends [A, D[, [D, F[, [F, H[, and [H, oo[
  *   Say that parent gets [A, D[ and [H, oo[, missing [D, F[ and [F, H[
  *   Upon receiving the TIDE ending at oo, or timing it out, parent sends TIRE indicating missing [A, H[

Once we are done one way, we can sync the other. Not sure we want both in parallel, you know better though.

All the best,

Pascal

From: RIFT <[email-masked]> On Behalf Of Pascal Thubert (pthubert)
Sent: jeudi 31 janvier 2019 10:35
To: Tony Przygienda <[email-masked]>; [email-masked]
Subject: Re: [Rift] Today's core meeting ...

Hello Tony

Works?

Pascal

From: RIFT <[email-masked]<mailto:[email-masked]>> On Behalf Of Tony Przygienda
Sent: jeudi 24 janvier 2019 19:28
To: [email-masked]<mailto:[email-masked]>
Subject: [Rift] Today's core meeting ...

upload:

--- tony

---

From: Bruno Rijsman <[email-masked]>
Date: Thu, 31 Jan 2019 09:01:03 -0600

Hi Pascal,

(For the impatient: scroll down to BOTTOM LINE below).

I like the idea of open ranges, allowing infinity (oo) to be used as the end-point for the final range.

One nitpick: AFAIK you cannot use a TIRE to request a missing range. You can only use a TIRE to request a missing individual TIE by setting the seq-nr to 0.  But that doesn’t change the core of the argument.

Consider X sending TIDEs to Y, and consider what happens when UDP re-orders the blasted TIDEs.

X sends:   [A,D[   [D,F[   [F,H[   [H,oo[

UDP re-orders and Y gets:  [A,D[   [H,oo[   [D,F[   [F,H[   

In this case, Y sees the gap between D[ and [H, and assume that X is missing those TIEs, and will send all TIEs in range [D,H[

Then, probably a fraction of second later, Y receives TIDEs [D,F[ and [F,H[ and realizes that it sent the TIEs for nothing…

I pointed out that scenario to Tony early on. Initially Tony didn’t think it was going to be an issue, but he recently saw that exact scenario happening in large-scale initial convergences.

During the call we agreed to scrap the rule that causes TIEs to be sent based on gaps in consecutive TIDEs.

Thus, when Y receives  [A,D[   [H,oo[  it is not going to react by sending all TIEs in range [D,H[

Instead, Y will patiently wait to receive [D,F[   [F,H[. 

Y will send TIEs based on gaps observed *inside* a TIDE but not based on gaps observed *between* TIDEs.

This takes care of handling re-ordered TIDEs more elegantly.

But, may cause delayed convergence if TIDEs are dropped rather than re-ordered.

For example, X sends:   [A,D[   [D,F[   XXX   [H,oo[  where XXX indicates that [F,H[ is dropped.

If Y does not react to gaps between TIDEs, then nothing will happen until TIDE [F,H[ is eventually resent….

BOTTOM LINE:

Consider what would happen if we follow both Pascal’s proposal and Tony’s proposal:

1) We use open range as Pascal proposes

2) That would allow us to recognize the final range by virtue of the fact that the endpoint is infinity oo

3) We don’t allow gaps between TIDEs as Tony proposes

4) That would mean that if Y observes a gap between TIDEs, it must be because a TIDE was dropped or re-ordered (there are no “natural” gaps).

5) When Y receives the final TIDE (endpoint is oo) it could start a short timer to allow re-ordered TIDEs to arrive

6) When the short timer expires, Y looks at gaps between received TIDEs. 

7) If Y sees a gap between TIDEs, it must be because a TIDE from X to Y was dropped.

8) Here comes the dilemma: what do we do next?  The correct action is NOT for Y to start sending TIEs.  What Y really wants is for X to resend the missing TIDE quickly.  But we have no mechanism for that.

— Bruno

> On Jan 31, 2019, at 4:02 AM, Pascal Thubert (pthubert) <[email-masked]> wrote:
> 
> Follow up:
>  
> When the adjacency comes up, child starts blasting its TIDEs, no new “sequence counter”
> Say that child sends [A, D[, [D, F[, [F, H[, and [H, oo[
> Say that parent gets [A, D[ and [H, oo[, missing [D, F[ and [F, H[
> Upon receiving the TIDE ending at oo, or timing it out, parent sends TIRE indicating missing [A, H[
>  
> Define 0 and infinity. 0 may be present, infinity cannot.
> In the start indicate the first that’s in (that’s A)
> In the end indicate the first that in not in (that’s D)
> Then place descriptors A, B and C
>  
> From: RIFT <[email-masked] <mailto:[email-masked]>> On Behalf Of Tony Przygienda
> To: [email-masked] <mailto:[email-masked]>
> https://www.dropbox.com/sh/z72t8ae85inl8we/AAAbsfXIQ-_j-N3SWVD0Cr_Fa?dl=0 <https://www.dropbox.com/sh/z72t8ae85inl8we/AAAbsfXIQ-_j-N3SWVD0Cr_Fa?dl=0>
>  
> --- tony
>  
>  
> _______________________________________________
> RIFT mailing list
> [email-masked]
> https://www.ietf.org/mailman/listinfo/rift