IEN74
Sequence Number Arithmetic
William W. Plummer
Bolt Beranek and Newman, Inc.
50 Moulton Street
Cambridge MA 02138
21 September 1978
Internet Experiment Note 74 21 September 1978
Sequence Number Arithmetic William W. Plummer
1. Introduction
TCP deals with 32bit numbers for sequencing and acknowledging data. A
basic concept is that of a "window", a range of sequence numbers which
begins at a "left" pointer and ends at a "right" pointer. Because a window
may contain sequence number zero, deciding whether a given number is within
a window is somewhat complicated. This paper describes some techniques for
dealing with sequence numbers as they apply to TCP.
2. Representation
The space of 2**32 sequence numbers will be shown as a (rough) circle:
0
 2**32  1
.....
. .
Increasing  . .
Numbers  . .
V . .
. .
.....
Segments of sequence numbers will be shown as:
........************.........>
Increasing numbers
^ ^
 
Left Right
Note that Left is the the first number within the segment. Right is not
included. That is, the segment is semiopen. If Left = Right, the segment
is considered to have zero length, not 2**32.
3. The CheckWindow Function
Because the sequence number space is actually a ring and arithmetic is done
modulo 2**32, there is no concept of one sequence number being greater (or
less) than another. The fundamental function for comparing sequence
numbers is CheckWindow(Left, Sequence, Right). This function returns true
if Sequence is contained in the semiopen segment between Left and Right.
 1 
Internet Experiment Note 74 21 September 1978
Sequence Number Arithmetic William W. Plummer
For machines with word sizes greater than 32bits or using unsigned
arithmetic on 32bit machines, the definition of CheckWindow is:
CheckWindow(L, S, R) := (L le R) =>
L le S and S lt R ,
not ( R le S and S lt L)
The second branch of the conditional is expressed in a way that it is the
complement of the first branch when L and R are interchanged. Advantage
is taken of this symmetry in the PDP10 code which implements CheckWindow.
Otherwise the second branch may be expressed as (R gt S) or (S ge L).
The first branch of the conditional is explained by the following diagram:
0
 2**32  1

oooo
xxx o
x  o
x ..... o
x . . o
x . . o
x . . o < Right
Left > o x * * x o
o x * * x o
o x ***** x o
o x x o
o xxxxxxx o
o o
oooooooooo
Key: ...... Basic sequence space
****** Segment between Left and Right
xxxxxx Sequence space where Sequence lt Right
oooooo Sequence space where Sequence ge Left
 2 
Internet Experiment Note 74 21 September 1978
Sequence Number Arithmetic William W. Plummer
The second branch of the conditional is the case where the segment crosses
zero:
0
 2**32  1

oooo
xxxx o
x  o
x ***** o
x * * o
x * * o
x * * o
Right > . * o < Left
. .
.....
Key: ..... Sequence space
***** Segment between Left and Right
ooooo Sequence numbers ge Left
xxxxx Sequence numbers lt Right
A useful identity is: CheckWindow(L, S, R) = not CheckWindow(R, S, L).
This says that either S is in the segment between L and R or it is
not.
4. OverLap(L1, R1, L2, R2)
OverLap(L1, R1, L2, R2) is a predicate which tells if the two segments L1
to R1 and L2 to R2 have at least one point in common. If an overlap
exists, then one segment must have its Left end within the other:
OverLap(L1, R1, L2, R2) :=
CheckWindow(L1, L2, R1) or CheckWindow(L2, L1, R2)
Either L2 is within segment one or it is not. So either CheckWindow(L1,
L2, R1) or not CheckWindow(L2, L1, R2) is true. In the first case there
is an overlap even if it is just at the point L2. The second term can be
rewritten:
 3 
Internet Experiment Note 74 21 September 1978
Sequence Number Arithmetic William W. Plummer
not CheckWindow(L2, L1, R2) = CheckWindow(R2, L1, L2).
Since L2 is outside segment one, it is the position of R2 which determines
whether an overlap exists. R2 can be either between L2 and L1 or it can
be between L1 and L2. Thus, there are two subcases: either
CheckWindow(L2, R2, L1) or CheckWindow(L1, R2, L2) must be true. In the
first case there is no overlap and segment one does not contain R2. If
the first case is not true then the second case must be since it is the
complement of the first with the first and third arguments switched.
5. Include(L1, R1, L2, R2)
Include is true if segment one includes all of segment two. This is true
only if the complement of segment one does not contain any of segment two.
Include(L1, R1, L2, R2) := not Overlap(R1, L1, L2, R2)
= CheckWindow(L1, L2, R1) and CheckWindow(R2, R1, L2)
The expansion states that L2 must lie in segment one and that the
complement of segment two must contain the right end of segment one.
6. Uses Within a TCP
The functions CheckWindow, Overlap, and Include have many uses within the
TCP. A few of these are described below. Some definitions are needed. A
TCB contains a Send.Left cell, a Send.Window, and Send.Sequence having to
do with packet generation. Send.Right does not exist explicitly but may be
computed by adding Send.Left and Send.Window (mod 2**32).
The receive side of a connection has the cells Recv.Left and Recv.Window .
Again, Recv.Right may be easily computed.
Each packet has its sequence number Pkt.Seq and an acknowledgement number
Pkt.AckSeq. The number called Pkt.End may be computed by counting one for
each control bit and data byte in the packet and adding this to Pkt.Seq mod
2**32. Note that Pkt.End is actually the sequence number following the
packet. Currently only SYN and FIN occupy sequence space and these occur
only at the start and end of a connection; otherwise, all sequence space is
occupied by data only.
 4 
Internet Experiment Note 74 21 September 1978
Sequence Number Arithmetic William W. Plummer
These variables define several segments. The send window between Send.Left
and Send.Right, the receive window between Recv.Left and Recv.Right, and
the packet segment between Pkt.Seq and Pkt.End. All of these segments are
semiopen and are suitable for manipulation by the previously described
functions such as CheckWindow.
The Retransmitter uses OverLap(Send.Left, Send.Right, Pkt.Seq, Pkt.End) to
tell if a packet has anything transmittable in it. Note that Send.Right
may lie within the segment between Send.Left and Send.Seq. This indicates
that the window shrank due to Send.Right having moved "backwards". In this
case data between Send.Right and Send.Seq is (temporarily) not
retransmittable.
The InputProcessor makes heavy use of all of the functions. The basic
acceptance test for packets arriving on an ESTABLISHED connection is
OverLap(Recv.Left, Recv.Right, Pkt.Seq, Pkt.End). If this is not true, the
packet is assumed to be either from the future or a duplicate from the
past.
Processing the Acknowledgement field of a packet involves a scan of the
retransmission queue to see which packets may be deleted. For each packet
on the queue CheckWindow(Send.Left, Pkt.End1, Acknowledgement) is true if
the packet has been acknowledged. Pkt.End1 is the sequence number of the
last byte in the packet. Note that any packet on the retransmission queue
must occupy at least one sequence number and therefore no special case
checks must be made worry about Pkt.End1 being less than Pkt.Seq .
TCP11 sends each newly typed character in a separate packet.
Retransmissions carry all unacknowledged data. TCP for the PDP10/20 tries
to minimize internal storage requirements by saving a retransmitted packet
and releasing the storage for the original transmissions. Given a incoming
packet InPkt, the following test is performed against each packet queued
for action by the buffer reassembler: Include(InPkt.Seq, InPkt.End,
QdPkt.Seq, QdPkt.End) means that the incoming packet contains at least as
much as the already queued packet and that the latter may be released.
 5 
Internet Experiment Note 74 21 September 1978
Sequence Number Arithmetic William W. Plummer
7. Sample Code
The following routines have been excerpted from the hand coded TCP for
TENEX and TOPS20. They have been included here to provide an indication of
complexity. Note that the PDP10 has a 36bit word size and thus 32bit
numbers are always positive. Operations such as CAM which are signed
compares on 36bit quantites are unsigned operations on 32bit numbers as
required.
; CheckWindow(Left, Sequence, Right)
; Test "Sequence" to see if it is between "Left" (inclusive) and "Right"
; (not incl.). Sequence numbers are modulo MAXSEQ and are always
; positive when represented in a 36bit word.
;T1/ Left
;T2/ Sequence
;T3/ Right
;
; CALL CHKWND
;Ret+1: always. T1 nonzero if Sequence is in the window
CHKWND::TEMP <VAL,SEQ,RIGHT,LEFT> ; Give names to T1, T2, T3, T4
MOVEM T1,LEFT ; Make T1 available for value
SETO VAL, ; Init value to TRUE
CAMG LEFT,RIGHT ; Crosses 0?
TDZA VAL,VAL ; No. Set VAL to FALSE.
EXCH LEFT,RIGHT ; Yes. Reverse Left and Right.
CAMGE SEQ,RIGHT
CAMGE SEQ,LEFT
CAIA
SETCA VAL, ; Complement VAL.
RESTORE
RET
By way of comparison, the BCPL expression for this compiles into
approximately 40 instructions on the PDP10. This expression is:
let CheckWindow(L, S, R) := (L le R) => (L le S < R), (R le S < L)
 6 
Internet Experiment Note 74 21 September 1978
Sequence Number Arithmetic William W. Plummer
; Test to see if two sequence number segments have one or more common
; points. The two segments are semiopen on the right, similar
; to CHKWND.
;T1/ Left1
;T2/ Right1
;T3/ Left2
;T4/ Right2
;
; CALL OVRLAP
;Ret+1 always, T1 nonzero if overlap exists
OVRLAP::LOCAL <LEFT1,LEFT2,RIGHT2> ; Define some local ACs.
MOVEM T1,LEFT1
DMOVEM T3,LEFT2 ; T3,T4 to LEFT2,RIGHT2
EXCH T2,T3
CALL CHKWND
JUMPN T1,OVRLAX
MOVE T1,LEFT2
MOVE T2,LEFT1
MOVE T3,RIGHT2
CALL CHKWND
OVRLAX: RESTORE
RET
 7 