3.2.1.2. OpenSSL 1.1 vs OpenSSL 3.0 vs WolfSSL 5.5

This section compares the performance of the cryptographic libraries that RTI Connext supports. We compare the performance of the OpenSSL 3, OpenSSL 1.1.1, and wolfSSL 5.5 cryptographic libraries. Changes in the patch versions of those libraries (last digit in the OpenSSL 3 or wolfSSL version numbers, letter in the OpenSSL 1 version number) should not have a great effect on the performance results.

Notice that these tests use the cryptographic libraries along to the RTI Connext code, however, in order to prove that these differences are not due to the RTI Connext specific code we also gathered some metrics isolating the Cryptographic operations, see Cryptographic Libraries section.

Linux x64

Minimum LatencyMaximum Throughput

• Not using security libraries

• No protection

• RTPS Sign

• RTPS Encrypt

• RTPS Sign with Original Auth, Data Encrypt

• RTPS Sign, Submessage Encrypt with Original Auth, Data Encrypt

• RTPS Sign, Submessage Encrypt

Perftest Scripts

To produce these tests, we executed RTI Perftest for C++98. The scripts used to execute the tests can be found here:

#!/bin/bash
filename=$0
script_location=$(cd "$(dirname "$filename")" || exit 255; pwd)

export datasizes="32 64 128 256 512 1024 2048 4096 8192 16384 32768 63000"
export datasizes_extended="${datasizes} 100000 500000 1048576 1548576 4194304 10485760"

export domain="2"
export exec_time=20
export num_reps=1
export instance_number=100000
export core=0
export run_batching_tests="1"
export run_no_batching_tests="1"
export nic_loss_rate=0
export nic_delay_ms=0

# We will use some colors to improve visibility of errors and info messages.
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
LIGHTBLUE='\033[0;36m'
NC='\033[0m'
INFO_TAG="${GREEN}[INFO][$role]:${NC}"
WARNING_TAG="${YELLOW}[WARNING][$role]:${NC}"
ERROR_TAG="${RED}[ERROR][$role]:${NC}"

################################################################################

function disable_colors() {
    export RED=""
    export GREEN=""
    export YELLOW=""
    export NC=""
    export BLUE=""
    export LIGHTBLUE=""
    export INFO_TAG="${GREEN}[INFO][$role]:${NC}"
    export WARNING_TAG="${YELLOW}[WARNING][$role]:${NC}"
    export ERROR_TAG="${RED}[ERROR][$role]:${NC}"
}

function change_domain() {
    if [[ "$domain" == "1" ]]; then
        export domain="2"
    else
        export domain="1"
    fi
}

# Function to process and append lines to the output file
function append_to_output_file() {
    local line=${1?line required}; readonly line
    local append=$(echo "${2?append required}" | tr -s ' '); readonly append
    local file=${3?file required}; readonly file
    if [[ "${line: -1}" == $'\n' ]]; then
        line="${line::-1}"
    fi
    echo "${line}${append}" >> "$file"
}

# Usage: execute_test <keyed/unkeyed> <rel/be> <datasizes> <batchSize>
function execute_test() {

    local keyed_unkeyed=$1
    local rel_be=$2
    local datasizes_test=$3
    local other_args=$4
    local name_suffix=$5

    local commands_string_test=$commands_string
    local tag=""

    if [[ "${keyed_unkeyed}" == "keyed" ]]; then
        commands_string_test="${commands_string_test} -keyed -instances $instance_number"
        tag="[${YELLOW}${transport}${NC}|${BLUE}K${NC}|"
    else
        tag="[${YELLOW}${transport}${NC}|${LIGHTBLUE}UK${NC}|"
    fi

    if [[ "${rel_be}" == "be" ]]; then
        commands_string_test="${commands_string_test} -bestEffort"
        tag="${tag}${YELLOW}BE${NC}]"
    else
        tag="${tag}${RED}REL${NC}]"
    fi

    # If batch_size is set to a non-zero value, we will add it to the command line of the publisher side.
    # When batch_size is 0, it is already handled by the no-batching block which appends -batchSize 0 to commands_string.
    if [[ "$batch_size" != "" && "$batch_size" != "0" && "$role" == "pub" ]]; then
        commands_string_test="${commands_string_test} -batchSize $batch_size"
    fi

    tag="${tag}[${LIGHTBLUE}${lat_thr}${NC}]"

    local output_file=$output_folder/${lat_thr}_${role}_${keyed_unkeyed}_${rel_be}${name_suffix}.csv

    if [[ "$role" == "pub" ]]; then
        echo -e "${YELLOW}[TEST]: $keyed_unkeyed, $rel_be, Is a no-batching test = $no_batching_tests. ${NC}"
    fi

    if [[ "$thread_cpu_affinity" != "" && "$LANGUAGE" != "java" && "$LANGUAGE" != "cs" ]]; then
        commands_string_test="${commands_string_test} -threadCPUAffinity $thread_cpu_affinity"
    fi

    local pre_command_string=""

    if [[ "$thread_priorities" != "" && "$LANGUAGE" != "java" && "$LANGUAGE" != "cs" ]]; then
        echo -e "${WARNING_TAG} Thread priorities enabled, this requires using sudo"
        # When using sudo, the LD_LIBRARY_PATH is emptied, hence we need to set it again in the command itself
        export LD_LIBRARY_PATH_COPIED="$LD_LIBRARY_PATH"
        pre_command_string="sudo LD_LIBRARY_PATH=$LD_LIBRARY_PATH_COPIED "
        commands_string_test="${commands_string_test} -threadPriorities $thread_priorities"
    fi

    if [[ "$pin_memory" != "" && "$LANGUAGE" != "java" && "$LANGUAGE" != "cs" ]]; then
        commands_string_test="${commands_string_test} -pinMemory"
    fi

    if [[ "$no_taskset" == "" && "$thread_cpu_affinity" == "" && "$LANGUAGE" != "java" && "$LANGUAGE" != "cs" ]]; then
        pre_command_string="$pre_command_string taskset -c $core"
    fi

    if [[ "$LANGUAGE" == "python" ]]; then
        pre_command_string="$pre_command_string python3 "
    fi

    if [[ "$DOCKER" == "1" ]]; then
        pre_command_string="$pre_command_string docker run --net=host -v /home/perfuser/rti_license_connextpro.dat:/opt/rti.com/rti_connext_dds-7.3.0/rti_license.dat rticom/perftest:7.3.0-EAR "
        executable=""
    fi

    # Get the aprox time this will take:
    total_tests=$((`wc -w <<< "$datasizes_test"` * num_reps))
    total_time=$((total_tests * exec_time))

    touch $output_file
    local no_headers=""
    local current_test=0
    for index in $(seq 1 ${num_reps}); do
        for DATALEN in ${datasizes_test}; do
            current_test=$((current_test + 1))

            if [[ ! -s $output_file ]]; then
                echo -e "${INFO_TAG} Output file is empty, filling the header."
                no_headers=""
            else
                echo -e "${INFO_TAG} Output file is not empty."
                no_headers=" -noOutputHeaders"
            fi

            export command="$pre_command_string $executable -domain $domain -dataLen $DATALEN $commands_string_test $other_args $no_headers"
            if [[ "$role" == "pub" ]]; then
                echo -e "Test ${tag} (${current_test}/${total_tests}) -- Total time = ${total_time}s"
                echo -e ${BLUE}$command${NC}
            else
                echo -e ${LIGHTBLUE}$command${NC}
            fi

            # In certain cases we need to wait a bit before running the test, this is
            # because the previous test might not be finished on the other side yet, or because the
            # discovery mechanism does not work like in connext DDS.
            if [[ "$LANGUAGE" == "cs" && "$role" == "pub" ]]; then
                sleep 3
            fi
            if [[ "$raw" == "1" && "$role" == "sub" ]]; then
                sleep 5
            fi

            # Gather netstat info before running the test
            if [[ "${get_netstat_info}" == "1" ]]; then
                echo -e "${INFO_TAG} Getting netstat info before"
                netstat -s -u | grep -e "error" -e "packet" > $output_folder/${lat_thr}_${role}_${keyed_unkeyed}_${rel_be}${name_suffix}_netstat_before.txt
            fi

            # Execute the command and capture the output
            if [[ $LANGUAGE == "c++98" || $LANGUAGE == "" ]]; then
                echo -e "${INFO_TAG} Using C++98, using -outputFile option"
                touch ${output_file}_tmp_line
                chmod 777 ${output_file}_tmp_line
                eval $command -outputFile ${output_file}_tmp_line
            else
                eval $command > ${output_file}_tmp_line
            fi

            number_of_lines=$(wc -l < ${output_file}_tmp_line)
            echo -e "${INFO_TAG} Size of the output text: $number_of_lines lines"

            # Check if this is the first test for this output file.
            local is_first_test=0
            if [[ ! -s $output_file ]]; then
                is_first_test=1
            fi
            local expected_lines=$((is_first_test+1))

            if [[ $number_of_lines -ne ${expected_lines} ]]; then
                echo -e "${WARNING_TAG} The output text should have ${expected_lines} lines, but it has ${number_of_lines}."
                echo -e "${RED} The content is: \n\"\"\""
                cat ${output_file}_tmp_line
                echo -e "\"\"\""
                echo -e "Not adding it to the output file. ${NC}"
            else
                if [[ $number_of_lines -gt 1 ]]; then
                    header_line=$(head -n 1 "${output_file}_tmp_line")
                    echo -e "${INFO_TAG} Header line is: $header_line"
                fi
                result_line=$(tail -n 1 "${output_file}_tmp_line")
                echo -e "${INFO_TAG} Result line is: $result_line"

                # If this is the first test, we need to add the header line to the output file
                if [[ $is_first_test -eq 1 ]]; then
                    append_to_output_file "$header_line" ", command-line" $output_file
                fi

                command=$(echo $command | sed 's/,/:comma:/g')
                # Remove the `"` characters from the command line
                command=$(echo $command | sed 's/\"//g')

                # Append the result line to the output file
                append_to_output_file "$result_line" ", $command" $output_file
            fi

            # Always remove the temporary file
            rm -rf ${output_file}_tmp_line

            # Gather netstat info after running the test
            if [[ "${get_netstat_info}" == "1" ]]; then
                echo -e "${INFO_TAG} Getting netstat info after"
                netstat -s -u | grep -e "error" -e "packet" > $output_folder/${lat_thr}_${role}_${keyed_unkeyed}_${rel_be}${name_suffix}_netstat_after.txt
                touch "$output_folder/${lat_thr}_${role}_${keyed_unkeyed}_${rel_be}${name_suffix}_netstat.csv"
                python3 $script_location/../../../tools/diff_netstat_output.py \
                    -n $output_folder/${lat_thr}_${role}_${keyed_unkeyed}_${rel_be}${name_suffix}_netstat_after.txt \
                    -o $output_folder/${lat_thr}_${role}_${keyed_unkeyed}_${rel_be}${name_suffix}_netstat_before.txt \
                    -d $DATALEN $no_header_netstat \
                    -csv >> "$output_folder/${lat_thr}_${role}_${keyed_unkeyed}_${rel_be}${name_suffix}_netstat.csv"
                rm -rf $output_folder/${lat_thr}_${role}_${keyed_unkeyed}_${rel_be}${name_suffix}_netstat_*.txt
                no_header_netstat=" -nh"
            fi

            change_domain
        done
    done
}

################################################################################
# PARSE COMMAND LINE OPTIONS:

while [ "$1" != "" ]; do
    case $1 in
        --executable)
            executable=$2
            shift
            ;;
        --docker)
            DOCKER="1"
            ;;
        --output-folder)
            output_folder=$2
            shift
            ;;
        --role)
            export role=$2
            shift
            ;;
        --core)
            export core=$2
            shift
            ;;
        --assign-core-list | --thread-cpu-affinity)
            export thread_cpu_affinity=$2
            shift
            ;;
        --assign-thread-priorities | --thread-priorities)
            export thread_priorities=$2
            shift
            ;;
        --pin-memory)
            export pin_memory="1"
            ;;
        --test-kind)
            export lat_thr=$2
            shift
            ;;
        --interface1)
            export interface=$2
            shift
            ;;
        --interface2)
            export interface2=$2
            shift
            ;;
        --ip1)
            export ip1=$2
            shift
            ;;
        --ip2)
            export ip2=$2
            shift
            ;;
        --repetitions)
            export num_reps=$2
            shift
            ;;
        --domain)
            export domain=$2
            shift
            ;;
        --execution-time)
            export exec_time=$2
            shift
            ;;
        --transport)
            export transport=$2
            shift
            ;;
        --datalen)
            export datalen_input=$2
            shift
            ;;
        --file-suffix)
            export file_suffix=$2
            shift
            ;;
        --folder-suffix)
            export folder_suffix=$2
            shift
            ;;
        --sub-folder)
            sub_folder=$2
            shift
            ;;
        --executable-suffix)
            export executable_suffix=$2
            shift
            ;;
        --extra-arguments)
            export extra_arguments=$2
            shift
            ;;
        --extra-arguments-pub)
            export extra_arguments_pub=$2
            shift
            ;;
        --extra-arguments-sub)
            export extra_arguments_sub=$2
            shift
            ;;
        --skip-be)
            export skip_be_tests="1"
            ;;
        --skip-rel)
            export skip_rel_tests="1"
            ;;
        --skip-keyed)
            export skip_keyed_data="1"
            ;;
        --skip-large-data)
            export skip_large_data="1"
            ;;
        --large-data)
            export large_data="1"
            ;;
        --keyed)
            export skip_unkeyed="1"
            ;;
        --unkeyed)
            export skip_keyed_data="1"
            ;;
        --no-batching | --skip-batching)
            export run_batching_tests="0"
            export run_no_batching_tests="1"
            ;;
        --skip-no-batching)
            export run_batching_tests="1"
            export run_no_batching_tests="0"
            ;;
        --batch-size)
            export batch_size=$2
            shift
            ;;
        --reliable)
            export skip_be_tests="1"
            ;;
        --best-effort)
            export skip_rel_tests="1"
            ;;
        --security-gov)
            export security_only="$2"
            shift
            ;;
        --micro)
            export micro="1"
            ;;
        --cert)
            export cert="1"
            ;;
        --raw | --raw-transport)
            export raw="1"
            ;;
        --tss)
            export tss="1"
            ;;
        --no-colors)
            export NO_COLORS="1"
            ;;
        --language)
            export LANGUAGE=$2
            shift
            ;;
        --loss-rate | --nic-loss-rate | --nic-loss-rate-percent)
            export nic_loss_rate=$2
            export configure_network="1"
            shift
            ;;
        --delay | --nic-delay-ms | --nic-delay)
            export nic_delay_ms=$2
            export configure_network="1"
            shift
            ;;
        --get-netstat-info | --netstat)
            export get_netstat_info="1"
            ;;
        --reduced-data-sizes-set)
            export REDUCED_DATA_SIZES_SET="1"
            ;;
        --dont-change-tuned-settings)
            export dont_change_tuned_settings="1"
            ;;
        --no-taskset)
            export no_taskset=1
            ;;
        --asynchronous | --async)
            export ASYNC="1"
            ;;
        *)
            echo -e "unknown parameter \"$1\""
            exit 255
            ;;
    esac
    shift
done

if [[ "$NO_COLORS" == "1" ]]; then
    disable_colors
fi

export folder_base="$(dirname "${executable}")"/../../..

if [[ $LANGUAGE == "java"  || "$LANGUAGE" == "cs" ]]; then
    export folder_base="$(dirname "${executable}")"/../..
fi
if [[ $tss == "1" ]]; then
    export folder_base="$(dirname "${executable}")"/../../../../..
fi

if [[ "${executable_suffix}" != "" ]]; then
    export executable="${executable}${executable_suffix}"
fi

if [[ -n "${folder_suffix}" ]]; then
    export output_folder="${output_folder}${folder_suffix}"
fi

if [[ -n "${sub_folder}" ]]; then
    export output_folder="${output_folder}/${sub_folder}"
fi

if [[ "${ASYNC}" == "1" ]]; then
    export output_folder="${output_folder}/async"
fi

echo -e "${INFO_TAG} Perftest executable is: $executable"
echo -e "${INFO_TAG} Output folder is: $output_folder"

################################################################################

if [[ "$LANGUAGE" == "python" ]]; then
    export skip_keyed_data="1"
    export skip_large_data="1"
    export skip_be_tests="1"
    export run_no_batching_tests="0"
fi

if [[ "$LANGUAGE" == "java" || "$LANGUAGE" == "cs" ]]; then
    # Java and C# perftest do not support these execution options.
    unset thread_cpu_affinity
    unset thread_priorities
    unset pin_memory
    export no_taskset=1
fi

if [[ "${skip_large_data}" == "1" ]]; then
    export datasizes_extended=${datasizes}
elif [[ "${large_data}" == "1" ]]; then
    export datasizes=${datasizes_extended}
fi

if [[ "${datalen_input}" != "" ]]; then
    echo -e "${YELLOW}[TEST] Testing only for ${datalen_input}${NC}"
    export datasizes=${datalen_input}
    export datasizes_extended=${datalen_input}
    if [[ "${run_no_batching_tests}" == "1" && "${run_batching_tests}" == "0" ]]; then
        export skip_large_data="1"
    fi
else 
    if [[ "${REDUCED_DATA_SIZES_SET}" != "" ]]; then
        echo -e "${YELLOW}[TEST] Testing Reduced set of datasizes ${NC}"
        export datasizes="32 128 512 2048 8192 32768 63000"
        export datasizes_extended="${datasizes} 102400 1048576 10485760"
    fi
fi

if [[ "$role" != "pub" && "$role" != "sub" ]]; then
    echo -e "${ERROR_TAG} It must be either publisher or subscriber"
    exit 255
fi

if [[ "$lat_thr" != "thr" && "$lat_thr" != "lat" ]]; then
    echo -e "${ERROR_TAG} It must be either lat or thr"
    exit 255
fi

if [[ "${interface}" == "" ]]; then
    echo "Using default nics"
    export nic_publisher=${ip_machine_1}
    export nic_subscriber=${ip_machine_2}
elif [[ "${interface}" == "both" ]]; then
    export nic_publisher="enp1s0f0,eno1"
    export nic_subscriber="enp1s0f0,eno1"
    echo -e "${INFO_TAG} Using nic_publisher: ${nic_publisher}"
    echo -e "${INFO_TAG} Using nic_subscriber: ${nic_subscriber}"
else
    export nic_publisher=$interface
    echo -e "${INFO_TAG} Using nic_publisher: ${nic_publisher}"

    if [[ "${interface2}" == "" ]]; then
        export nic_subscriber=$interface
    else
        export nic_subscriber=$interface2
    fi
    echo -e "${INFO_TAG} Using nic_subscriber: ${nic_subscriber}"

    if [[ "${ip1}" != "" ]]; then
        export ip_publisher=$ip1
        echo "Using ip_publisher: ${ip_publisher}"
    fi

    if [[ "${ip2}" != "" ]]; then
        export ip_subscriber=$ip2
        echo "Using ip_subscriber: ${ip_subscriber}"
    fi

fi

if [[ "$transport" != "" ]]; then
    export transport_string="-transport $transport"

    if [[ "$transport" == "UDPv4" ]]; then

        export transport_string_pub="$transport_string -nic $nic_publisher"
        export transport_string_sub="$transport_string -nic $nic_subscriber"

        if [[ "$raw" == "1" ]]; then
            export transport_string_pub="$transport_string_pub -peer ${ip_subscriber}"
            export transport_string_sub="$transport_string_sub -peer ${ip_publisher}"
        fi

        if [[ "$micro" == "1" || "$cert" == "1" ]]; then
            export transport_string_pub="$transport_string_pub -peer _udp://${ip_subscriber}"
            export transport_string_sub="$transport_string_sub -peer _udp://${ip_publisher}"
        fi

    elif [[ "$transport" == "TCP" ]]; then
        export transport_string_pub="$transport_string \
            -nic $nic_publisher \
            -peer 0@tcpv4_lan://${ip_subscriber}:7400"
        export transport_string_sub="$transport_string \
            -nic $nic_subscriber \
            -peer 0@tcpv4_lan://${ip_publisher}:7400"
    elif [[ "$transport" == "TLS" ]]; then
        export transport_string_pub="$transport_string \
            -nic $nic_publisher \
            -peer tlsv4_lan://${ip_subscriber}:7400"
        export transport_string_sub="$transport_string \
            -nic $nic_subscriber \
            -peer tlsv4_lan://${ip_publisher}:7400"
    elif [[ "$transport" == "UDPv4_WAN" ]]; then
        export transport_string_pub="$transport_string \
            -nic $nic_publisher \
            -transportPublicAddress $ip_publisher:7400"
        export transport_string_sub="$transport_string \
            -nic $nic_subscriber \
            -peer 0@udpv4_wan://${ip_publisher}:7400"
    else
        export transport_string_pub="$transport_string"
        export transport_string_sub="$transport_string"
    fi
fi

################################################################################

export pub_string="-pub \
        ${transport_string_pub} \
        -noPrintIntervals \
        -executionTime $exec_time"

if [[ ${lat_thr} == "lat" ]]; then
    export pub_string="$pub_string \
        -latencyTest"
fi

if [[ "$role" == "pub" ]]; then

    if [[ "$configure_network" == "1" ]]; then
        echo -e "${INFO_TAG} Adding -initialBurst 1 to publisher side"
        export pub_string="$pub_string -initialBurst 1"
    fi

    if [[ "$ASYNC" == "1" ]]; then
        export pub_string="${pub_string} -asynchronous"
    fi
fi

export sub_string="-sub \
        ${transport_string_sub} \
        -noPrintIntervals"

if [[ "$role" == "pub" ]]; then
    echo -e "$INFO_TAG Publisher side running"
    export commands_string=${pub_string}
    export extra_arguments="${extra_arguments} ${extra_arguments_pub}"
else
    echo -e "$INFO_TAG Subscriber side running"
    export commands_string=${sub_string}
    export extra_arguments="${extra_arguments} ${extra_arguments_sub}"
fi

###############################################################################

if [[ "$dont_change_tuned_settings" != "1" ]]; then
    echo -e "${INFO_TAG} Executing: /set_${lat_thr}_mode.sh"
    sudo /set_${lat_thr}_mode.sh
    sleep 5
fi

if [[ "$role" == "pub" ]]; then
    export interface_to_configure=$nic_publisher
else
    export interface_to_configure=$nic_subscriber
fi

echo -e "${INFO_TAG} Resetting network interface to default state"
# Try to delete any existing netem rules (ignore errors if none exist)
sudo tc qdisc del dev $interface_to_configure root netem 2>/dev/null || true
# Reset to default (pfifo_fast)
sudo tc qdisc del dev $interface_to_configure root 2>/dev/null || true

if [[ "${configure_network}" == "1" ]]; then
    echo -e "${INFO_TAG} Setting loss rate to ${nic_loss_rate}% and delay to ${nic_delay_ms}ms"
    sudo tc qdisc add dev $interface_to_configure root netem loss ${nic_loss_rate}% delay ${nic_delay_ms}ms limit 10000000
fi

cd $folder_base
echo -e "${INFO_TAG} Folder Base is: $PWD"
mkdir -p $output_folder

if [[ "${batch_size}" != "" ]]; then
    if [[ "${lat_thr}" == "thr" ]]; then
        if [[ "${batch_size}" -eq 0 ]]; then
            echo -e "${INFO_TAG} Batch size is set to 0"
            export run_batching_tests="0"
            export run_no_batching_tests="1"
        else
            echo -e "${INFO_TAG} Batch size is set to ${batch_size}"
            export run_batching_tests="1"
            export run_no_batching_tests="0"
        fi
    else
        echo -e "${INFO_TAG} Batch size is set to ${batch_size}. This value will be ignored for latency tests."
        unset batch_size
    fi
fi

# Tests that may use batching (when doing throughput tests). Also Latency tests.
if [[ ${run_batching_tests} == "1" ]]; then

    # UNKEYED
    if [[ "${skip_unkeyed}" == "" ]]; then

        # RELIABLE
        if [[ "${skip_rel_tests}" == "" ]]; then
            # For the time being, we will skip the throughput reliable tests for CERT.
            # More info in PERF-1175
            if ! [[ "${cert}" == "1" && "${lat_thr}" == "thr" && "${transport}" == "UDPv4" ]]; then
                execute_test "unkeyed" "rel" "${datasizes_extended}" "${extra_arguments}" "$file_suffix"
            else
                echo -e "${INFO_TAG} Skipping reliable throughput tests for CERT. See PERF-1175 for more information."
            fi
        fi

        # BEST EFFORT
        if [[ "${skip_be_tests}" == "" ]]; then
            execute_test "unkeyed" "be" "${datasizes}" "${extra_arguments}" "$file_suffix"
        fi
    fi

    # KEYED
    if [[ "${skip_keyed_data}" == "" ]]; then

        # RELIABLE
        if [[ "${skip_rel_tests}" == "" ]]; then
            execute_test "keyed" "rel" "${datasizes}" "${extra_arguments}" "$file_suffix"
        fi

        # BEST EFFORT
        if [[ "${skip_be_tests}" == "" ]]; then
            execute_test "keyed" "be" "${datasizes}" "${extra_arguments}" "$file_suffix"
        fi
    fi

fi

# Tests that will not use batching
if [[ "${lat_thr}" == "thr" && "${run_no_batching_tests}" == "1" ]]; then

    if [[ "$role" == "pub" ]]; then
        export commands_string="${commands_string} -batchSize 0"
    fi

    # UNKEYED
    if [[ "${skip_unkeyed}" == "" ]]; then

        # RELIABLE
        if [[ "${skip_rel_tests}" == "" ]]; then
            execute_test "unkeyed" "rel" "${datasizes}" "${extra_arguments}" "_noBatch${file_suffix}"
        fi

        # BEST EFFORT
        if [[ "${skip_be_tests}" == "" ]]; then
            execute_test "unkeyed" "be" "${datasizes}" "${extra_arguments}" "_noBatch${file_suffix}"
        fi
    fi

    # KEYED
    if [[ "${skip_keyed_data}" == "" ]]; then

        # RELIABLE
        if [[ "${skip_rel_tests}" == "" ]]; then
            execute_test "keyed" "rel" "${datasizes}" "${extra_arguments}" "_noBatch${file_suffix}"
        fi

        # BEST EFFORT
        if [[ "${skip_be_tests}" == "" ]]; then
            execute_test "keyed" "be" "${datasizes}" "${extra_arguments}" "_noBatch${file_suffix}"
        fi
    fi

fi

# Replace the cleanup section at the end:
if [[ "${configure_network}" == "1" ]]; then
    echo -e "${INFO_TAG} Resetting network interface to default state"
    sudo tc qdisc del dev $interface_to_configure root netem 2>/dev/null || true
    sudo tc qdisc del dev $interface_to_configure root 2>/dev/null || true
fi

#!/bin/bash
filename=$0
script_location=$(cd "$(dirname "$filename")" || exit 255; pwd)

export input_params=$@

while [ "$1" != "" ]; do
    case $1 in
        --executable)
            executable=$2
            shift
            ;;
        --security-gov)
            export security_only=$2
            shift
            ;;
        --ci)
            export CI="1"
            ;;
        *)
            ;;
    esac
    shift
done

echo $security_only

export folder_base="$(dirname "${executable}")"/../../..
export PATH_TO_GOVERNANCE_FILES_FOLDER=$folder_base/resource/secure

if [[ "${CI}" == "" ]]; then

    if [[ "${security_only}" == "none" || "${security_only}" == "" ]]; then
        echo -e "[Calling base_script/script.sh] -- No Security"
        "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
             --skip-be --skip-no-batching \
            --file-suffix "_security_none"
        sleep 5;
    fi

    if [[ "${security_only}" == "rtps_sign" || "${security_only}" == "" ]]; then
        echo -e "[Calling base_script/script.sh] -- RTPS Sign"
        "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
             --skip-be --skip-no-batching \
            --extra-arguments "-secureGovernanceFile $PATH_TO_GOVERNANCE_FILES_FOLDER/signed_PerftestGovernance_RTPSSign.xml " \
            --file-suffix "_security_rtps_sign"
    fi

    if [[ "${security_only}" == "rtps_sign_submessage_encrypt" || "${security_only}" == "" ]]; then
        echo -e "[Calling base_script/script.sh] -- RTPS Sign, Submessage Encrypt"
        "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
             --skip-be --skip-no-batching \
            --extra-arguments "-secureGovernanceFile $PATH_TO_GOVERNANCE_FILES_FOLDER/signed_PerftestGovernance_SignEncryptSubmessage.xml " \
            --file-suffix "_security_rtps_sign_submessage_encrypt"
    fi

fi

if [[ "${security_only}" == "no_protection" || "${security_only}" == "" ]]; then
    echo -e "[Calling base_script/script.sh] -- No Protection"
    "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
         --skip-be --skip-no-batching \
        --extra-arguments "-secureGovernanceFile $PATH_TO_GOVERNANCE_FILES_FOLDER/signed_PerftestGovernance_.xml " \
        --file-suffix "_security_no_protection"
fi

if [[ "${security_only}" == "rtps_encrypt" || "${security_only}" == "" ]]; then
    echo -e "[Calling base_script/script.sh] -- RTPS Encrypt"
    "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
         --skip-be --skip-no-batching \
        --extra-arguments "-secureGovernanceFile $PATH_TO_GOVERNANCE_FILES_FOLDER/signed_PerftestGovernance_RTPSEncrypt.xml " \
        --file-suffix "_security_rtps_encrypt"
fi

if [[ "${security_only}" == "rtps_sign_submessage_encrypt_orig_data_encrypt" || "${security_only}" == "" ]]; then
    echo -e "[Calling base_script/script.sh] -- RTPS Sign, Submessage Encrypt with original auth, Data Encrypt"
    "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
         --skip-be --skip-no-batching \
        --extra-arguments "-secureGovernanceFile $PATH_TO_GOVERNANCE_FILES_FOLDER/signed_PerftestGovernance_RTPSSignEncryptSubmessageWithOrigAuthEncryptData.xml " \
        --file-suffix "_security_rtps_sign_submessage_encrypt_orig_data_encrypt"
fi

if [[ "${security_only}" == "rtps_sign_orig_data_encrypt" || "${security_only}" == "" ]]; then
    echo -e "[Calling base_script/script.sh] -- RTPS Sign with Original auth, Data Encrypt"
    "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
         --skip-be --skip-no-batching \
        --extra-arguments "-secureGovernanceFile $PATH_TO_GOVERNANCE_FILES_FOLDER/signed_PerftestGovernance_RTPSSignWithOrigAuthEncryptData.xml " \
        --file-suffix "_security_rtps_sign_orig_data_encrypt"
    sleep 5;
fi

if [[ "${security_only}" == "protectionDomainLevel" || "${security_only}" == "" ]]; then
    echo -e "[Calling base_script/script.sh] -- RTPS Sign with Original auth, Data Encrypt"
    "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
        --extra-arguments "-secureGovernanceFile $PATH_TO_GOVERNANCE_FILES_FOLDER/signed_PerftestGovernance_protectionDomainLevel.xml -securePSK data:,1:SecretKey" \
        --file-suffix "_security_protection_domain_level"
    sleep 5;
fi

if [[ "${security_only}" == "protectionTopicLevel" || "${security_only}" == "" ]]; then
    echo -e "[Calling base_script/script.sh] -- RTPS Sign with Original auth, Data Encrypt"
    "${script_location}/../base_script/script.sh" $input_params --transport UDPv4 \
        --extra-arguments "-secureGovernanceFile $PATH_TO_GOVERNANCE_FILES_FOLDER/signed_PerftestGovernance_protectionTopicLevel.xml -securePSK data:,1:SecretKey" \
        --file-suffix "_security_protection_topic_level"
    sleep 5;
fi

Security Profiles

Test Hardware

The following hardware was used to perform these tests:

Linux Nodes

Dell R340 Servers (13 Units)
Processor: Intel Xeon E-2278G (3.4-5GHz, 8c/16t, 16MB cache, 2 memory channels @2666MHz)
RAM: 4x 16GB 2666MHz DIMM (64GB RAM)
HD: 480GB SATA SSD
NIC 1: Intel 710 dual port 10Gbps SFP
OS: Ubuntu 20.04 -- gcc 9.3.0

Switch

Dell 2048 -- 10Gbps switch (10Gbps and 1Gbps interfaces)