What is the one way latency?

Hello,

I believe when you say that you have been doing some performance testing you mean with the RTI Perftest application, am I right?

In that case, you are right: We measure the RTT (Round Trip Time), which corresponds to the time it takes for a sample to be sent from the publisher to the subscriber, send it back and be received in the publisher side. We assume that time is symetric (time to go equals to time to receive) and then we divide by 2, getting the Latency (One way latency).

Now, the next question is, what kind of test are you performing? Let me explain, in RTI Perftest by default you do a Throughput test, and you might be interested in doing a latencyTest:

Doing a throughput test means that it will start sending samples as fast as possible, and once every `latencyCount` samples (which for a Throughput test is 10000 samples), it will mark the sample so it is answered by the subscriber. The answer is the exact same sample, so, by getting the time when you sent it and the time when you receive it back you can get the Round-Trip Time (RTT).

The important thing here is that: Doing a Throughput test will give you the maximum throughput (mbps) at what the publisher will be able to send samples to a subscriber. The latency you will get there is there impacted by the fact that you are in a crowed network, with your queues being full. If you want to test the minimum latency you will be able to achieve, you will need to do a Latency Test instead.

In order to do a latency test, you will only need to add `-LatencyTest` to your RTI Perftest publisher command line parameters. This will change the behavior of the test. Now, instead of trying to send as fast as possible, it will do a ping pong test: Send a sample and wait until it receives it back to calculate the RTT (and therefore the Latency), then send again.

Let me know if this helps!

- With regards to your first question, you exposed something that can be improved in RTI Perftest, let me show you:

In the code, the first time we receive a sample of a given size, we don't print the latency, we just print the message you see with the datalen chage:

"********** New data length is 4096"

There in the code, internally, we do this:

// if data sized changed
        if (_lastDataLength != message.size) {
            _lastDataLength = message.size;

            if (_lastDataLength != 0 && PerfTest.printIntervals) {
                System.out.printf(
                        "\n\n********** New data length is %1$d\n",
                        _lastDataLength + PerfTest.OVERHEAD_BYTES);
            }
        } else if (PerfTest.printIntervals) {
            double latency_ave = (double)_latencySum / (double)_count;

            double latency_std = sqrt(
                (double)_latencySumSquare / (double)_count - (latency_ave * latency_ave));

            System.out.printf(
                "One-Way Latency: %1$6d us  Ave %2$6.0f us  Std %3$6.1f us  Min %4$6d us  Max %5$6d" + outputCpu + "\n",
                latency,
                latency_ave,
                latency_std,
                _latencyMin,
                _latencyMax
            );
        }

        // if data sized changed
        if (_lastDataLength != message.size) {
            _lastDataLength = message.size;

            if (_lastDataLength != 0 && PerfTest.printIntervals) {
                System.out.printf(
                        "\n\n********** New data length is %1$d\n",
                        _lastDataLength + PerfTest.OVERHEAD_BYTES);
            }

            // Same code as in the else:
            double latency_ave = 0;
            if (_count != 0) {
                 latency_ave = (double)_latencySum / (double)_count;
            }

            double latency_std = sqrt(
                (double)_latencySumSquare / (double)_count - (latency_ave * latency_ave));

            System.out.println("1st Case ** Count is " + _count);
            System.out.printf(
                "1st Case ** One-Way Latency: %1$6d us  Ave %2$6.0f us  Std %3$6.1f us  Min %4$6d us  Max %5$6d" + outputCpu + "\n",
                latency,
                latency_ave,
                latency_std,
                _latencyMin,
                _latencyMax
            );
        } else if (PerfTest.printIntervals) {
            double latency_ave = (double)_latencySum / (double)_count;

            double latency_std = sqrt(
                (double)_latencySumSquare / (double)_count - (latency_ave * latency_ave));

            System.out.println("** Count is " + _count);
            System.out.printf(
                "One-Way Latency: %1$6d us  Ave %2$6.0f us  Std %3$6.1f us  Min %4$6d us  Max %5$6d" + outputCpu + "\n",
                latency,
                latency_ave,
                latency_std,
                _latencyMin,
                _latencyMax
            );
        }

********** New data length is 4096
1st Case ** Count is 1
1st Case ** One-Way Latency:   4720 us  Ave   4720 us  Std    0.0 us  Min   4720 us  Max   4720
** Count is 2
One-Way Latency:   1116 us  Ave   2918 us  Std 1802.0 us  Min   1116 us  Max   4720
** Count is 3
One-Way Latency:    163 us  Ave   2000 us  Std 1962.5 us  Min    163 us  Max   4720
** Count is4

Hi,

Let me see if I understand correctly the question: Since you are running a latency test (-latencyTest), you would expect every single sample to be answered, and therefore you would expect to see a row per sample in the publisher side, however you are seeing more than the number of samples being sent.

This is weird, because, as you well thought, I would expect every sample to be received once, and only once.

I was unable to reproduce this behavior, I've been using the following command line parameters:

Publisher

bin/release/perftest_java.sh -pub -latencyTest -numIter 1000

Subscriber

bin/release/perftest_java.sh -sub

But every single time I was getting 999 lines. I also tried by using the -executionTime, with similar results.

I instrumented the code adding these lines to the "LatencyListener.java" file, right after where we print the "One-Way Latency:"

            System.out.printf(
                "Samples received: %1$6d samples\n",
                _count
            );

But in my case, numbers match.

Could you also instrument the code as I did adding these lines and see where you receive more samples? Also, this is not probable, but could you check if in your system you have more RTI Perftest applications running.

What command lines are you using and what version of RTI Perftest?

Regards,

Javi