2. cnp3-ebook
3. principles/reliability
4. English
5. Zen

176 ../../principles/reliability.rst:854
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The simplest sliding window protocol uses the `go-back-n` recovery. Intuitively, `go-back-n` operates as follows. A `go-back-n` receiver is as simple as possible. It only accepts the frames that arrive in-sequence. A `go-back-n` receiver discards any out-of-sequence frame that it receives. When `go-back-n` receives a data frame, it always returns an acknowledgment containing the sequence number of the last in-sequence frame that it has received. This acknowledgment is said to be `cumulative`. When a `go-back-n` receiver sends an acknowledgment for sequence number `x`, it implicitly acknowledges the reception of all frames whose sequence number is earlier than `x`. A key advantage of these cumulative acknowledgments is that it is easy to recover from the loss of an acknowledgment. Consider for example a `go-back-n` receiver that received frames `1`, `2` and `3`. It sent `OK1`, `OK2` and `OK3`. Unfortunately, `OK1` and `OK2` were lost. Thanks to the cumulative acknowledgments, when the sender receives `OK3`, it knows that all three frames have been correctly received. 1082/10000 · 1082
177 ../../principles/reliability.rst:856
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The figure below shows the FSM of a simple `go-back-n` receiver. This receiver uses two variables : `lastack` and `next`. `next` is the next expected sequence number and `lastack` the sequence number of the last data frame that has been acknowledged. The receiver only accepts the frame that are received in sequence. `maxseq` is the number of different sequence numbers (:math:`2^n`). 385/10000 · 385
178 ../../principles/reliability.rst:890
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A `go-back-n` sender is also very simple. It uses a sending buffer that can store an entire sliding window of frames [#fsizesliding]_. The frames are sent with increasing sequence numbers (modulo `maxseq`). The sender must wait for an acknowledgment once its sending buffer is full. When a `go-back-n` sender receives an acknowledgment, it removes from the sending buffer all the acknowledged frames and uses a retransmission timer to detect frame losses. A simple `go-back-n` sender maintains one retransmission timer per connection. This timer is started when the first frame is sent. When the `go-back-n sender` receives an acknowledgment, it restarts the retransmission timer only if there are still unacknowledged frames in its sending buffer. When the retransmission timer expires, the `go-back-n` sender assumes that all the unacknowledged frames currently stored in its sending buffer have been lost. It thus retransmits all the unacknowledged frames in the buffer and restarts its retransmission timer. 1011/10000 · 1011
179 ../../principles/reliability.rst:932
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The operation of `go-back-n` is illustrated in the figure below. In this figure, note that upon reception of the out-of-sequence frame `D(2,c)`, the receiver returns a cumulative acknowledgment `C(OK,0)` that acknowledges all the frames that have been received in sequence. The lost frame is retransmitted upon the expiration of the retransmission timer. 354/10000 · 354
180 ../../principles/reliability.rst:938
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Go-back-n : example 19/10000 · 19
181 ../../principles/reliability.rst:941
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The main advantage of `go-back-n` is that it can be easily implemented, and it can also provide good performance when only a few frames are lost. However, when there are many losses, the performance of `go-back-n` quickly drops for two reasons : 245/10000 · 245
182 ../../principles/reliability.rst:943
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — the `go-back-n` receiver does not accept out-of-sequence frames 63/10000 · 63
183 ../../principles/reliability.rst:944
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — the `go-back-n` sender retransmits all unacknowledged frames once it has detected a loss 88/10000 · 88
184 ../../principles/reliability.rst:951
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — `Selective repeat` is a better strategy to recover from losses. Intuitively, `selective repeat` allows the receiver to accept out-of-sequence frames. Furthermore, when a `selective repeat` sender detects losses, it only retransmits the frames that have been lost and not the frames that have already been correctly received. 324/10000 · 324
185 ../../principles/reliability.rst:953
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A `selective repeat` receiver maintains a sliding window of `W` frames and stores in a buffer the out-of-sequence frames that it receives. The figure below shows a five-frame receive window on a receiver that has already received frames `7` and `9`. 249/10000 · 249
186 ../../principles/reliability.rst:959
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The receiving window with selective repeat 42/10000 · 42
187 ../../principles/reliability.rst:961
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A `selective repeat` receiver discards all frames having an invalid CRC, and maintains the variable `lastack` as the sequence number of the last in-sequence frame that it has received. The receiver always includes the value of `lastack` in the acknowledgments that it sends. Some protocols also allow the `selective repeat` receiver to acknowledge the out-of-sequence frames that it has received. This can be done for example by placing the list of the correctly received, but out-of-sequence frames in the acknowledgments together with the `lastack` value. 557/10000 · 557
188 ../../principles/reliability.rst:963
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — When a `selective repeat` receiver receives a data frame, it first verifies whether the frame is inside its receiving window. If yes, the frame is placed in the receive buffer. If not, the received frame is discarded and an acknowledgment containing `lastack` is sent to the sender. The receiver then removes all consecutive frames starting at `lastack` (if any) from the receive buffer. The payloads of these frames are delivered to the user, `lastack` and the receiving window are updated, and an acknowledgment acknowledging the last frame received in sequence is sent. 572/10000 · 572
189 ../../principles/reliability.rst:965
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The `selective repeat` sender maintains a sending buffer that can store up to `W` unacknowledged frames. These frames are sent as long as the sending buffer is not full. Several implementations of a `selective repeat` sender are possible. A simple implementation associates one retransmission timer to each frame. The timer is started when the frame is sent and canceled upon reception of an acknowledgment that covers this frame. When a retransmission timer expires, the corresponding frame is retransmitted and this retransmission timer is restarted. When an acknowledgment is received, all the frames that are covered by this acknowledgment are removed from the sending buffer and the sliding window is updated. 714/10000 · 714
190 ../../principles/reliability.rst:967
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The figure below illustrates the operation of `selective repeat` when frames are lost. In this figure, `C(OK,x)` is used to indicate that all frames, up to and including sequence number `x` have been received correctly. 219/10000 · 219
191 ../../principles/reliability.rst:973
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Selective repeat : example 26/10000 · 26
192 ../../principles/reliability.rst:977
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Pure cumulative acknowledgments work well with the `go-back-n` strategy. However, with only cumulative acknowledgments a `selective repeat` sender cannot easily determine which frames have been correctly received after a data frame has been lost. For example, in the figure above, the second `C(OK,0)` does not inform explicitly the sender of the reception of `D(2,c)` and the sender could retransmit this frame although it has already been received. A possible solution to improve the performance of `selective repeat` is to provide additional information about the received frames in the acknowledgments that are returned by the receiver. For example, the receiver could add in the returned acknowledgment the list of the sequence numbers of all frames that have already been received. Such acknowledgments are sometimes called `selective acknowledgments`. This is illustrated in the figure above. 899/10000 · 899
193 ../../principles/reliability.rst:986
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In the figure above, when the sender receives `C(OK,0,[2])`, it knows that all frames up to and including `D(0,...)` have been correctly received. It also knows that frame `D(2,...)` has been received and can cancel the retransmission timer associated to this frame. However, this frame should not be removed from the sending buffer before the reception of a cumulative acknowledgment (`C(OK,2)` in the figure above) that covers this frame. 440/10000 · 440
194 ../../principles/reliability.rst:990
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Maximum window size with `go-back-n` and `selective repeat` 59/10000 · 59
195 ../../principles/reliability.rst:992
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A reliable protocol that uses `n` bits to encode its sequence number can send up to :math:`2^n` successive frames. However, to ensure a reliable delivery of the frames, `go-back-n` and `selective repeat` cannot use a sending window of :math:`2^n` frames. Consider first `go-back-n` and assume that a sender sends :math:`2^n` frames. These frames are received in-sequence by the destination, but all the returned acknowledgments are lost. The sender will retransmit all frames. These frames will all be accepted by the receiver and delivered a second time to the user. It is easy to see that this problem can be avoided if the maximum size of the sending window is :math:`{2^n}-1` frames. A similar problem occurs with `selective repeat`. However, as the receiver accepts out-of-sequence frames, a sending window of :math:`{2^n}-1` frames is not sufficient to ensure a reliable delivery. It can be easily shown that to avoid this problem, a `selective repeat` sender cannot use a window that is larger than :math:`\frac{2^n}{2}` frames. 1035/10000 · 1035