Hoe kun je gegarandeerde gegevenslevering via het UDP-protocol garanderen?

Gegarandeerde levering via UDP, zijnde een verbindingloos protocol zonder leveringsgarantie, vereist de implementatie van betrouwbaarheidsmechanismen op applicatieniveau of via middleware. De belangrijkste benaderingen omvatten:

1. Bevestigingsmechanismen (Acknowledgements - ACK): De zender voegt in elk datagram een identificator toe (bijvoorbeeld een sequentienummer). De ontvanger stuurt een ontvangstbevestiging voor elk succesvol ontvangen datagram.
2. Mechanismen voor retransmissie: De zender stelt een timer in na het verzenden van een datagram. Als er geen bevestiging wordt ontvangen voordat de timer afloopt, wordt het datagram als verloren beschouwd en opnieuw verzonden.
3. Mechanismen voor duplicaatcontrole: De ontvanger houdt de identificatoren van ontvangen datagrams bij en verwerpt duplicaten als ze ontstaan door retransmissies.
4. Mechanismen voor volgordebewaking: Hoewel UDP geen volgorde garandeert, kan de applicatie sequentienummers gebruiken om datagrams te herschikken aan de kant van de ontvanger.
5. Stroomcontrole: Indien nodig kan een mechanisme worden geïmplementeerd dat overloop van de buffer van de ontvanger voorkomt.

Het implementeren van deze mechanismen vereist aanzienlijke inspanningen op applicatieniveau of het gebruik van gespecialiseerde bibliotheken/protocollen gebouwd bovenop UDP, bijvoorbeeld:

• Reliable User Datagram Protocol (RUDP): Een uitbreiding van UDP die betrouwbaarheid toevoegt.
• Quic: Een door Google ontwikkeld transportprotocol dat over UDP werkt en functionaliteiten biedt vergelijkbaar met TCP (betrouwbaarheid, stroomcontrole, beveiliging), maar met verbeterde verbindingsopstarttijden en minder invloed bij pakketverlies.
• Protocollen voor realtime communicatie met gedeeltelijke betrouwbaarheid: Bijvoorbeeld, Secure Real-time Transport Protocol (SRTP) kan optionele betrouwbaarheidsmechanismen bevatten.

Voorbeeld van schematische logica aan de zenderkant:

# pseudocode voor illustratie

data_to_send = [...] # lijst van datagrams
sent_packets = {}    # woordenboek: sequentienummer -> (gegevens, verzendtijd)
next_seq_num = 0
ack_timeout = 0.1    # seconden
max_retransmissions = 5

for data in data_to_send:
    packet = (next_seq_num, data)
    send_udp(packet)
    sent_packets[next_seq_num] = (packet, time.time(), 0) # pakket, verzendtijd, aantal herhalingen
    next_seq_num += 1

while sent_packets:
    # Wacht op bevestigingen
    acks = receive_acks() # simulatie van ontvangst bevestigingen
    for seq_num in acks:
        if seq_num in sent_packets:
            del sent_packets[seq_num] # verwijderen uit wachtlijst

    # Controleer time-outs en herhaal
    current_time = time.time()
    packets_to_retransmit = []
    for seq_num, (packet, send_time, retransmit_count) in sent_packets.items():
        if current_time - send_time > ack_timeout:
            if retransmit_count < max_retransmissions:
                packets_to_retransmit.append(seq_num)
            else:
                # Pakket definitief verloren na MaxRetransmissions
                handle_packet_loss(seq_num)
                del sent_packets[seq_num]

    for seq_num in packets_to_retransmit:
        packet, _, retransmit_count = sent_packets[seq_num]
        send_udp(packet)
        sent_packets[seq_num] = (packet, time.time(), retransmit_count + 1) # update tijd en teller

Zo'n implementatie creëert in feite een protocol bovenop UDP dat het gedrag van TCP imiteert op het gebied van betrouwbaarheid. De keuze van een specifieke aanpak hangt af van de eisen van de applicatie (bijvoorbeeld, latency, bandbreedte). Voor de meeste gevallen waarbij betrouwbaarheid vereist is, is het aan te raden om bestaande protocollen (TCP, QUIC) of bewezen bibliotheken te gebruiken.