Making packet delivery as fast as possible

[yankee624]

I want the received packets to be delivered to the application as fast as possible (without TSBPD buffering, without retransmission).
Currently, if I turn off TSBPD, it doesn't allow packet gap so it waits until the missing packet arrives.
However, I want to make it directly deliver the packet to app even if there's a packet gap (thus allowing packet loss).
By doing this, I want each packet's end-to-end latency (=from the time when srt_sendmsg is called, to the time when the packet is received with srt_recvmsg) to be always ~=RTT/2, regardless of packet loss rate.

My try

SRT_TRANSTYPE=SRTT_LIVE, SRTO_RCVLATENCY=0.
In this setting, the end-to-end latency is set to be RTT_estimated/2.

Test environment

• Ubuntu 18.04
• SRT version: commit 3cefede
• localhost connection (so the RTT should be nearly 0ms)
• Continuously send 1316 byte data through srt_sendmsg with some interval in-between.

I have some questions regarding this approach.

1. When the interval between srt_sendmsg calls varies, the end-to-end latency fluctuates.
   SRT seems to adjust the packet sending period based on the srt_sendmsg interval.
   To the best of my knowledge, this should not happen in LiveCC since PKT_SND_PERIOD = PktSize * 1000000 / MAX_BW. link
   So with same Pktsize 1316, send period should be constant. I wonder why this happens.

2. If the estimated RTT is longer than the actual RTT, the frame buffering time (until RTT_estimated/2) may still exist. I haven't seen this case yet but I wonder if this may happen.

3. It doesn't turn off the retransmission. So it may unnecessarily send NAK.

Do these drawbacks actually exist?
And would there be a better approach?

[ethouris]

Did you set this zero latency on one side or both? Because the effective latency is the maximum of two.

If you have two endpoints, A and B, then the latency in the direction A -> B is the maximum of:

• SRTO_RCVLATENCY as set on endpoint B
• SRTO_PEERLATENCY as set on endpoint A

Of course, you can set the same latency in both directions, in which case simply set it to SRTO_LATENCY on both endpoints.

The latency currently serves two purposes:

• Defines the extra time towards ETS (see below) to forcefully keep the packet in the buffer
• Defines the extra time for how long to wait for recovery of a lost packet preceding the received one

The packet is kept in the buffer up to this packet's PTS, and only up to that time lost packets preceding it have a chance to get recovered.

PTS is more-less defined this way:

• RTS[x] = time when the packet x has been received from the network
• ETS[x] = time when the packet x is expected to be received
• TS[x] = timestamp written in the packet x (corrected by counter override tracking)

The base time is taken from the packet 0, the first ever received data packet. Then:

• ETS[x] = RTS[0] + (TS[x] - TS[0])
• PTS[x] = ETS[x] + LATENCY(preset) + DRIFT(runtime-tracked)

So, if you simply set latency to 0, packets will be delivered immediately to the application, and also packets will be dropped immediately after reception of the packet following the loss, without any chance of recovery. This will happen already in TSBPD thread, so before even the application is informed about a packet ready to deliver.

Also, according to the tests, RTS for further packets happens most likely to be later than ETS (which is equal to PTS in case of zero latency, and when we ignore DRIFT). This means that practically every packet will be ready to deliver immediately upon reception, and will cause dropping every lost packet preceding it also in this moment.

In effect, with zero latency and TLPKTDROP turned on (default) you'll get from the SRT transmission exactly the same as on bare UDP. You can, of course, turn TLPKTDROP off, but with this you risk HOL-blocking, which can even lead to breaking the connection in the live mode, caused by the receiver buffer overflow. To avoid this, you'd need some mechanism to force dropping lost packets only or request, which doesn't exist. And it's not exactly easy to add.

I'm not sure what you are trying to achieve. TSBPD is required to ensure that the time, when an I-Frame is delivered to the decoder, is the same distant towards the previous I-Frame's delivery time as the difference in their PTS. Without this mechanism this would have to be ensured by the application to deliver the information at the right time. And there's still no way to avoid the risk of breaking the transmission when waiting for a packet recovery takes too long.

[yankee624]

Thank you so much for your prompt reply.

What I'm trying to achieve is, as you mentioned, configuring SRT to be similar to bare UDP. I want to compare this udp-similar srt with original srt / tcp-similar srt (maybe file mode, or live mode with tlpktdrop off).
Anyway, I want to get some help in making SRT similar to bare UDP (achieving constant RTT/2 latency)

I set zero latency on both sides.
But I found out that the end-to-end latency fluctuates when the interval between srt_sendmsg varies. This is different from my expectation that the end-to-end latency should be constant (~=RTT/2) just like bare UDP. It should send the packet right after srt_sendmsg call without any congestion control.

1. I suspect that SRT is adjusting the packet sending period (the time from srt_sendmsg call to the time when the packet is actually sent.
   To the best of my knowledge, this should not happen in LiveCC since PKT_SND_PERIOD = PktSize * 1000000 / MAX_BW. link
   So with same Pktsize 1316, send period should be constant.
   Why would this happen? Is there some kind of hidden congestion control in live mode?

2. One worry I have about this approach is that...
   When LATENCY option is set to 0, the end-to-end latency is set to RTT_estimated/2 + drift.
   So if the RTT or drift is incorrectly estimated, it may lead to fluctuating end-to-end latency.

I would really appreciate any other idea to achieve constant RTT/2 end-to-end latency.

[yankee624]

Here's the test code and some results with different SEND_INTERVAL between srt_sendmsg calls.

I set one way delay to 50ms with linux tc netem. (Therefore the end-to-end latency should be approximately 50ms.)
Then I measured latency with two settings.

1. Constant interval (50us) between srt_sendmsg calls.
2. Variable interval (50us 20 times, 20000us 1 time): This represents the case where we send all the packets of frame 1 quickly, then sleep until frame 2 arrives, then send all the packets of frame 2 quickly...

The result is as follows.

[Sender]

#include <fstream>
#include <iostream>
#include <cstdlib>
#include <string>
#include <sstream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <srt.h>
#include <chrono>
#include <thread>

#define IP "127.0.0.1"
#define PORT "9000"
#define FRAME_INTERVAL 0
#define PKT_INTERVAL 50

#define TOTAL_FRAMES 100
#define PKT_PER_FRAME 20

using namespace std;

int main(int argc, char* argv[])
{
    srt_startup();

    srt_setloglevel(srt_logging::LogLevel::debug);

    struct addrinfo hints, *peer;

    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_DGRAM;
    SRTSOCKET fhandle = srt_create_socket();

    int32_t rcvlatency = 0;
    if (SRT_ERROR == srt_setsockopt(fhandle, 0, SRTO_RCVLATENCY, &rcvlatency, sizeof rcvlatency)) {
        cout << "srt_setsockopt: " << srt_getlasterror_str() << endl;
        return 0;
    }

    if (0 != getaddrinfo(IP, PORT, &hints, &peer))
    {
        cout << "incorrect server/peer address. " << endl;
        return -1;
    }
    srt_connect(fhandle, peer->ai_addr, peer->ai_addrlen);


    freeaddrinfo(peer);
    int idx = 0;

    for (int frame = 0; frame < TOTAL_FRAMES; frame++) {
        for (int pkt = 0; pkt < PKT_PER_FRAME; pkt++) {
            char input[1316];

            memcpy(input, &idx, sizeof(idx));
            int64_t time = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
            memcpy(input + sizeof(int), &time, sizeof(time));

            int nsnd = srt_sendmsg(fhandle, input, sizeof(input), -1, true);
            if (nsnd == SRT_ERROR)
            {
                cout << "SRT ERROR: " << srt_getlasterror_str() << endl;
                break;
            }
            idx++;

            // Some interval between sendmsg call
            usleep(PKT_INTERVAL);
        }
        usleep(FRAME_INTERVAL);
    }
    
   srt_close(fhandle);
   srt_cleanup();
   return 0;
}

[Receiver]

#include <cstdlib>
#include <netdb.h>
#include <fstream>
#include <iostream>
#include <string>
#include <cstring>
#include <srt.h>
#include <assert.h> 
#include <chrono>
#define PORT "9000"

using namespace std;

int main(int argc, char* argv[])
{
   srt_startup();
   srt_setloglevel(srt_logging::LogLevel::debug);

   addrinfo hints;
   addrinfo* res;
   memset(&hints, 0, sizeof(struct addrinfo));
   hints.ai_flags = AI_PASSIVE;
   hints.ai_family = AF_INET;
   hints.ai_socktype = SOCK_DGRAM;
   string service(PORT);
   if (0 != getaddrinfo(NULL, service.c_str(), &hints, &res))
   {
      cout << "illegal port number or port is busy.\n" << endl;
      return 0;
   }

   SRTSOCKET sfd = srt_create_socket();
   if (SRT_INVALID_SOCK == sfd)
   {
      cout << "srt_socket: " << srt_getlasterror_str() << endl;
      return 0;
   }

   int32_t rcvlatency = 0;
   if (SRT_ERROR == srt_setsockopt(sfd, 0, SRTO_RCVLATENCY, &rcvlatency, sizeof rcvlatency)) {
      cout << "srt_setsockopt: " << srt_getlasterror_str() << endl;
      return 0;
   }

   if (SRT_ERROR == srt_bind(sfd, res->ai_addr, res->ai_addrlen))
   {
      cout << "srt_bind: " << srt_getlasterror_str() << endl;
      return 0;
   }
   freeaddrinfo(res);
   if (SRT_ERROR == srt_listen(sfd, 10))
   {
      cout << "srt_listen: " << srt_getlasterror_str() << endl;
      return 0;
   }

   char data[1316];
   SRTSOCKET fhandle;
   sockaddr_storage clientaddr;
   int addrlen = sizeof(clientaddr);

   fhandle = srt_accept(sfd, (sockaddr*)&clientaddr, &addrlen);
   if (SRT_INVALID_SOCK == fhandle)
   {
      cout << "srt_accept: " << srt_getlasterror_str() << endl;
      return 0;
   }

   char clienthost[NI_MAXHOST];
   char clientservice[NI_MAXSERV];
   getnameinfo((sockaddr *)&clientaddr, addrlen,
               clienthost, sizeof(clienthost),
               clientservice, sizeof(clientservice), NI_NUMERICHOST|NI_NUMERICSERV);

   int prev_idx = -1;
   int idx;
   int total_cnt = 0;
   int loss_cnt = 0;
   ofstream latency_file("latency.csv");
   while (true)
   {  
      int ret = srt_recvmsg(fhandle, data, sizeof(data));
      if (SRT_ERROR == ret)
      {
         cout << "srt_recvmsg: " << srt_getlasterror_str() << endl;
         break;  
      }
      total_cnt++;
      memcpy(&idx, data, sizeof(int));
      if (idx != prev_idx + 1) {
         loss_cnt++;
      }
      prev_idx = idx;
      int64_t send_time;
      memcpy(&send_time, data + sizeof(int), sizeof(int64_t));
      int64_t e2e_latency = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - send_time;
      latency_file << e2e_latency << endl;
   }
   printf("loss cnt %d / %d (%f)\n", loss_cnt, total_cnt, (float)loss_cnt / total_cnt);

   srt_close(sfd);
   srt_cleanup();
   return 0;
}