Re: IPv6 day and tunnels

[Owen DeLong <owen () delong com>]

On Jun 4, 2012, at 7:47 PM, Jimmy Hess wrote:

> On 6/4/12, Owen DeLong <owen () delong com> wrote:
> [snip]
> > Probing as you have proposed requires you to essentially do a binary search
> > to arrive
> > at some number n where 1280≤n≤9000, so, you end up doing something like
> > this:
> [snip]
> > So, you waited for 13 timeouts before you actually passed useful
> > traffic? Or, perhaps you putter along at the lowest possible MTU until you
> [snip]
> Instead of waiting for 13 timeouts, start with 4 initial probes in
> parallel,  and react rapidly to the responses you receive;  say
> 9000,2200, 1500, 830.

What's the point of an 830 probe when the minimum valid MTU is 1280?

> Don't wait until any timeouts until the possible MTUs are narrowed.
>
>
> FindLocalMTU(B,T)
>   Let  B  :=  Minimum_MTU
>   Let T  := Maximum_MTU
>   Let  D :=   Max(1, Floor( ( (T - 1)  -  (B+1) ) / 4 ))
>   Let  R := T
>   Let  Attempted_Probes := []
>
>   While  ( ( (B + D) < T  )   or    Attempted_Probes is not Empty )  do
>        If    R is not a member  of   Attempted_Probes   or  Retries < 1  then
>               AsynchronouslySendProbeOfSize  (R)
>               Append (R,Tries) to list of Attempted_Probes  if not exists
>                   or  if  (R,Tries) already in list then increment Retries.

Did I miss the definition of Tries and/or Retries somewhere? ;-)

>       else
>                   T :=  R - 1
>                   Delete from Attempted_Probes (R)
>       end

>        if  ( (B +    D) < T )        AsynchronouslySendProbeOfSize  (B+ D)
>        if  ( (B + 2*D) < T )        AsynchronouslySendProbeOfSize  (B+ 2*D)
>        if  ( (B + 3*D) < T )       AsynchronouslySendProbeOfSize  (B+ 3*D)
>        if  ( (B + 4*D) < T )       AsynchronouslySendProbeOfSize  (B+ 4*D)

Shouldn't all of those be <= T?

>         Wait_For_Next_Probe_Response_To_Arrive()

>         Wait_For_Additional_Probe_Response_Or_Short_Subsecond_Delay()
>         Add_Probe_Responses_To_Queue(Q)

Not really a Queue, more of a list. In fact, no real need to maintain a list at all,
you could simply keep a variable Q and let Q=max(Q,Probe_response)

>         R :=  Get_Largest_Received_Probe_Size(Q)

Which would allow you to eliminate this line altogether and replace R below with Q.

>         If     ( R > T )     then
>                   T := R
>         end
>
>         If     ( R > B  )   then
>                   B := R
>                   D := Max(1, Floor( ( (R - 1)  -  (B+1) ) / 4 ))
>         end
>    done
>
>    Result :=  B
>
>
> #
>
> If you receive the response at n=830 first, then wait 1ms and send the
> next 4 probes 997   1164  1331  1498,  and resend the n=1500 probe
>    If 1280 is what the probe needs to detect.  You'll receive a
> response for 1164 , so wait 1ms  then retry  n=1498
>    next 4 probes are  1247  1330  1413  1496
>     if 1280 is what the probe needs to detect,  You'll receive a
> response for 1247, so wait 1ms  resend n=1496
>         next 4 probes are   1267 1307  1327   1347
>            if 1280 is what you neet to detect, you'll receive
> response for  1267, so
>               retry n=1347  wait 1ms
>              next 4 probes are:   1276  1285 1294 1303
>              next 4 probes are:   1277 1278 1279 1280
>                     next 2 parallel probes are:  1281 1282
>
> You hit after  22 probes,  but you only needed to wait for n=1281   n=1282
> and their retry to time out.

But that's a whole lot more packets than working PMTU-D to get there and
you're also waiting for all those round trips, not just the 4 timeouts.

The round trips add up if you're dealing with a 100ms+ RTT. 22 RTTs at
100ms is 2.2 seconds. That's a long time to go without first data packet
passed,

Owen