Go-Back-N ARQ

Go-Back-N Automatic Repeat Request (ARQ) is a type of error control protocol used in data transmission. It is a sliding window protocol that is used in the data link layer of OSI Model.

Working of Go-Back-N ARQ

• The sender sends a frame to the receiver and starts the timer.
• The receiver receives the frame and sends an ACKnowledgement (ACK) with the next expected frame number.
• The sender receives the ACK and removes the sent frames from the buffer.
• If the sender does not receive an ACK within a specific time, it retransmits all the unACKnowledged frames beginning from the last frame ACKnowledged by the receiver.

Features

• Uses a sliding window approach, allowing multiple frames to be sent without waiting for ACK.
• The receiver sends cumulative ACK, which acknowledges receipt of all frames up to the received frame's sequence number.
• If a frame is lost or damaged, the receiver discards it and sends a NAK (Negative ACK) specifying the expected sequence number. The sender then retransmits all the frames from the expected sequence number.
• Provides reliability and flow control, which ensures that data is transmitted efficiently without requiring an excess of resources.

Code Implementation

Here is a simple implementation of Go-Back-N ARQ in Python:

from time import time, sleep
import random

def sender():
    timeout = 2
    seq_num_bits = 3
    seq_limit = 2 ** seq_num_bits
    window_size = 4
    send_buffer = list(range(0, seq_limit))
    send_base = 0
    next_frame_to_send = 0
    while send_base < seq_limit:
        if (next_frame_to_send < send_base + window_size) and (next_frame_to_send < seq_limit):
            print("Sending frame", next_frame_to_send)
            sleep(random.uniform(0.1, 0.2))
            if random.randint(0, 1) == 1:
                print("ACK not received for frame", next_frame_to_send)
                continue
            if next_frame_to_send == send_base:
                start_timer = time()
            next_frame_to_send += 1
        if (time() - start_timer) > timeout:
            print("Timeout occurred for frame", send_base)
            next_frame_to_send = send_base
        if next_frame_to_send == (send_base + window_size) or next_frame_to_send == seq_limit:
            print("ACK received for all frames up to", next_frame_to_send)
            send_base = next_frame_to_send

def receiver():
    seq_num_bits = 3
    seq_limit = 2 ** seq_num_bits
    expected_frame = 0
    while expected_frame < seq_limit:
        if random.randint(0, 1) == 1:
            print("Frame lost for sequence number", expected_frame)
            continue
        print("Frame received with sequence number", expected_frame)
        sleep(random.uniform(0.1, 0.2))
        expected_frame += 1
    print("All frames received successfully.")

if __name__ == '__main__':
    sender()
    receiver()

This implementation demonstrates how the sender sends frames to the receiver in a sliding window approach. The sender waits for ACK for a specific time, and if not received, it retransmits all the unACKnowledged frames beginning from the last frame ACKnowledged by the receiver. The receiver sends cumulative ACK, acknowledging receipt of all frames up to the received frame's sequence number. If a frame is lost or damaged, the receiver discards it and sends a NAK specifying the expected sequence number. The sender then retransmits all the frames from the expected sequence number.

Conclusion

Go-Back-N ARQ is a reliable error control protocol that allows efficient flow control and ensures data transmission in a sliding window approach. Its features make it one of the most popular protocols used in data transmission today.