3.10. performance¶
3.10.1. performance_actions suite¶
3.10.1.1. Additional Statistics Action For bash-perf-stat¶
Additional Statistics Action for bash command “perf stat”.
Run Keyword If ${extended_debug}==${True} Perf Stat On All DUTs ${nodes} cpu_list=${cpu_alloc_str}
3.10.1.2. Additional Statistics Action For trex-runtime¶
Additional Statistics Action for T-Rex telemetry counters with running traffic. See documentation of the called keyword for required test variables.
${ppta} = Get Packets Per Transaction Aggregated
${ramp_up_duration} = Get Ramp Up Duration
${ramp_up_rate} = Get Ramp Up Rate
${runtime_duration} = Get Runtime Duration
${runtime_rate} = Get Runtime Rate
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
${use_latency} = Get Use Latency
Send traffic on tg duration=${-1} rate=${runtime_rate} frame_size=${frame_size} traffic_profile=${traffic_profile} async_call=${True} ppta=${ppta} use_latency=${use_latency} traffic_directions=${traffic_directions} transaction_duration=${transaction_duration} transaction_scale=${transaction_scale} transaction_type=${transaction_type} duration_limit=${0.0} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate}
Sleep 1s
Stop traffic on tg
3.10.1.3. Additional Statistics Action For vpp-runtime¶
Additional Statistics Action for clear and show runtime counters with running traffic. See documentation of the called keyword for required test variables.
${ppta} = Get Packets Per Transaction Aggregated
${ramp_up_duration} = Get Ramp Up Duration
${ramp_up_rate} = Get Ramp Up Rate
${runtime_duration} = Get Runtime Duration
${runtime_rate} = Get Runtime Rate
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
${use_latency} = Get Use Latency
Send traffic on tg duration=${-1} rate=${runtime_rate} frame_size=${frame_size} traffic_profile=${traffic_profile} async_call=${True} ppta=${ppta} use_latency=${use_latency} traffic_directions=${traffic_directions} transaction_duration=${transaction_duration} transaction_scale=${transaction_scale} transaction_type=${transaction_type} duration_limit=${0.0} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate}
Run Telemetry On All DUTs ${nodes} profile=vppctl_runtime.yaml
Stop traffic on tg
3.10.1.4. Additional Statistics Action For vpp-runtime-iperf3¶
Additional Statistics Action for clear and show runtime counters with iPerf3 running traffic. See documentation of the called keyword for required test variables.
${runtime_duration} = Get Runtime Duration
${pids}= iPerf Client Start Remote Exec ${nodes['${iperf_client_node}']} duration=${-1} rate=${None} frame_size=${None} async_call=True warmup_time=0 traffic_directions=${1} namespace=${iperf_client_namespace} udp=${iperf_client_udp} host=${iperf_server_bind} bind=${iperf_client_bind} affinity=${iperf_client_affinity}
Run Telemetry On All DUTs ${nodes} profile=vppctl_runtime.yaml
iPerf Client Stop Remote Exec ${nodes['${iperf_client_node}']} ${pids}
3.10.1.5. Additional Statistics Action For noop¶
Additional Statistics Action for no operation.
No operation
3.10.1.6. Additional Statistics Action For vpp-clear-stats¶
Additional Statistics Action for clear VPP statistics.
Run Telemetry On All DUTs ${nodes} profile=vppctl_clear_stats.yaml
3.10.1.7. Additional Statistics Action For vpp-enable-packettrace¶
Additional Statistics Action for enable VPP packet trace.
Run Keyword If ${extended_debug}==${True} VPP Enable Traces On All DUTs ${nodes} fail_on_error=${False}
3.10.1.8. Additional Statistics Action For vpp-show-packettrace¶
Additional Statistics Action for show VPP packet trace.
Run Keyword If ${extended_debug}==${True} Show Packet Trace On All Duts ${nodes} maximum=${100}
3.10.1.9. Additional Statistics Action For vpp-show-stats¶
Additional Statistics Action for show VPP statistics.
Run Telemetry On All DUTs ${nodes} profile=vppctl_show_stats.yaml
3.10.2. performance_display suite¶
3.10.2.1. Check NDRPDR interval validity¶
Extract loss ratio of lower bound of the interval. Fail if it does not reach the allowed value. Arguments: - interval - Measured interval. Type: ReceiveRateInterval - packet_loss_ratio - Accepted loss (0.0 for NDR). Type: float Example: | Check NDRPDR interval validity | ${result.pdr_interval} | ${0.005} |
${lower_bound} = Set Variable ${interval.measured_low}
${lower_bound_lr} = Set Variable ${lower_bound.loss_ratio}
Return From Keyword If ${lower_bound_lr} <= ${packet_loss_ratio}
Set Test Variable \${rate_for_teardown} ${lower_bound.target_tr}
${message}= Catenate SEPARATOR=${SPACE} Minimal rate loss ratio ${lower_bound_lr} does not reach target ${packet_loss_ratio}.
${message_zero} = Set Variable Zero packets forwarded!
${message_other} = Set Variable ${lower_bound.loss_count} packets lost.
${message} = Set Variable If ${lower_bound_lr} >= 1.0 ${message}${\n}${message_zero} ${message}${\n}${message_other}
Fail ${message}
3.10.2.2. Compute Bandwidth¶
Compute (bidir) bandwidth from given (unidir) transaction rate.
This keyword reads ${ppta} and ${avg_aggregated_frame_size} set elsewhere. The implementation should work for both pps and cps rates.
Arguments: - tps - Transaction rate (unidirectional) [tps]. Type: float
Returns: - Computed bandwidth in Gbps. - Computed aggregated packet rate in pps. Example: |${bandwidth} | ${pps} = | Compute Bandwidth | ${12345.67} |
${ppta} = Get Packets Per Transaction Aggregated
${pps} = Evaluate ${tps} * ${ppta}
${bandwidth} = Evaluate ${pps} * (${avg_aggregated_frame_size}+20)*8/1e9
Return From Keyword ${bandwidth} ${pps}
3.10.2.3. Display Reconfig Test Message¶
Display the number of packets lost (bidirectionally) due to reconfiguration under traffic. Arguments: - result - Result of bidirectional measurement. Type: ReceiveRateMeasurement Example: | Display Reconfig Test Message | ${result} |
${ppta} = Get Packets Per Transaction Aggregated
${packet_rate} = Evaluate ${result.target_tr} * ${ppta}
${packet_loss} = Set Variable ${result.loss_count}
${time_loss} = Evaluate ${packet_loss} / ${packet_rate}
Set Test Message Packets lost due to reconfig: ${packet_loss}
Set Test Message ${\n}Implied time lost: ${time_loss} append=yes
3.10.2.4. Display result of NDRPDR search¶
Display result of NDR+PDR search, both quantities, both bounds, aggregated, in units given by trasaction type, e.g. by default in packet per seconds and Gbps total bandwidth (for initial packet size).
The bound to display is encoded as target rate, it is assumed it is in transactions per second. Bidirectional traffic transaction is understood as having 2 packets, for this purpose.
Througput is calculated as: Sum of measured rate over streams Bandwidth is calculated as: (Throughput * (L2 Frame Size + IPG) * 8) If the results contain latency data, display them for lower bounds. Test (or broader scope) variables read: - frame_size_num - L2 Frame Size [B]. Type: integer or float - transaction_type - String identifier to determine how to count transactions. Default is “packet”. Arguments: - result - Measured result data. Aggregated rate, tps or pps. Type: NdrPdrResult Example: | Display result of NDRPDR search | ${result} |
Display single bound NDR_LOWER ${result[0].measured_low.target_tr} ${result[0].measured_low.latency}
Display single bound NDR_UPPER ${result[0].measured_high.target_tr}
Display single bound PDR_LOWER ${result[1].measured_low.target_tr} ${result[1].measured_low.latency}
Display single bound PDR_UPPER ${result[1].measured_high.target_tr}
3.10.2.5. Display result of soak search¶
Display result of soak search, avg+-stdev, as upper/lower bounds. See Display single bound for units used. Test (or broader scope) variables read: - frame_size - L2 Frame Size [B] or IMIX string. Type: integer or string - transaction_type - String identifier to determine how to count transactions. Default is “packet”. Arguments: - avg - Estimated average critical load [pps]. Type: float - stdev - Standard deviation of critical load [pps]. Type: float Returns: - Lower and upper bound of critical load [pps]. Type: 2-tuple of float Example: | Display result of soak search | ${100000} | ${100} |
${avg} = Convert To Number ${avg}
${stdev} = Convert To Number ${stdev}
${lower} = Evaluate ${avg} - ${stdev}
${upper} = Evaluate ${avg} + ${stdev}
Display single bound PLRsearch lower bound ${lower}
Display single bound PLRsearch upper bound ${upper}
Return From Keyword ${lower} ${upper}
3.10.2.6. Display single bound¶
Compute and display one bound of NDR+PDR (or soak) search result. If the latency string is present, it is displayed as well.
The bound to display is given as target transfer rate, it is assumed it is in transactions per second. Bidirectional traffic transaction is understood as having 2 packets, for this purpose.
Pps values are aggregated, in packet per seconds and Gbps total bandwidth (for initial packet size).
Througput is calculated as: Sum of measured rate over streams Bandwidth is calculated as: (Throughput * (L2 Frame Size + IPG) * 8) If the results contain latency data, display them for lower bounds. Test (or broader scope) variables read: - transaction_type - String identifier to determine how to count transactions. Default is “packet”. Arguments: - text - Flavor text describing which bound is this. Type: string - tps - Transaction rate [tps]. Type: float - latency - Latency data to display if non-empty. Type: string Example: | Display single bound | NDR lower bound | ${12345.67} | latency=${EMPTY} |
${transaction_type} = Get Transaction Type
Run Keyword And Return If """_cps""" in """${transaction_type}""" Display Single CPS Bound ${text} ${tps} ${latency}
Display Single PPS Bound ${text} ${tps} ${latency}
3.10.2.7. Display Single CPS Bound¶
Display one bound of NDR+PDR search for CPS tests. The bounds are expressed as transactions per second. If the latency string is present, it is displayed as well. Arguments: - text - Flavor text describing which bound is this. Type: string - tps - Transaction rate [tps]. Type: float - latency - Latency data to display if non-empty. Type: string Example: | Display Single CPS Bound | NDR lower bound | ${12345.67} | latency=${EMPTY} |
Set Test Message ${\n}${text}: ${tps} CPS append=yes
${bandwidth} ${pps} = Compute Bandwidth ${tps}
Export Search Bound ${text} ${tps} cps ${bandwidth * 1e9}
Return From Keyword If not """${latency}"""
Set Test Message ${\n}LATENCY [min/avg/max/hdrh] per stream: ${latency} append=yes
3.10.2.8. Display Single PPS Bound¶
Display one pps bound of NDR+PDR search, aggregated, in packet per seconds and Gbps total bandwidth (for initial packet size).
The bound to display is given as target transfer rate, it is assumed it is in transactions per second. Bidirectional traffic transaction is understood as having 2 packets, for this purpose.
Througput is calculated as: Sum of measured rates over streams Bandwidth is calculated as: (Throughput * (L2 Frame Size + IPG) * 8) If the latency string is present, it is displayed as well. Arguments: - text - Flavor text describing which bound is this. Type: string - tps - Transaction rate [tps]. Type: float - latency - Latency data to display if non-empty. Type: string Example: | Display Single PPS Bound | NDR lower bound | ${12345.67} | latency=${EMPTY} |
${bandwidth} ${pps} = Compute Bandwidth ${tps}
Set Test Message ${\n}${text}: ${pps} pps, append=yes
Set Test Message ${bandwidth} Gbps (initial) append=yes
Export Search Bound ${text} ${pps} pps ${bandwidth * 1e9}
Return From Keyword If not """${latency}"""
Set Test Message ${\n}LATENCY [min/avg/max/hdrh] per stream: ${latency} append=yes
3.10.3. performance_utils suite¶
3.10.3.1. Find critical load using PLRsearch¶
Find boundaries for troughput (of hardcoded target loss ratio) using PLRsearch algorithm. Display results as formatted test message. Fail if computed lower bound is 110% of the minimal rate or less. Input rates are unidirectional, in transaction per second. Reported result may contain aggregated pps rates, depending on test. Call ${resetter} (if defined) to reset DUT state before each trial. Test (or broader scope) variables read: - traffic_profile - Name of module defining traffc for measurements. Type: string - frame_size - L2 Frame Size [B] or IMIX string. Type: integer or string - max_rate - Calculated unidirectional maximal transmit rate [pps]. Type: float Example: | Find critical load using PLR search |
${max_rate} = Get Max Rate
${min_rate_soft} = Get Min Rate Soft
${ppta} = Get Packets Per Transaction Aggregated
${ramp_up_duration} = Get Ramp Up Duration
${ramp_up_rate} = Get Ramp Up Rate
${resetter} = Get Resetter
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
${use_latency} = Get Use Latency
${average} ${stdev} = Perform soak search frame_size=${frame_size} traffic_profile=${traffic_profile} minimum_transmit_rate=${min_rate_soft} maximum_transmit_rate=${max_rate} plr_target=${1e-7} tdpt=${0.1} initial_count=${50} ppta=${ppta} resetter=${resetter} timeout=${1800.0} trace_enabled=${False} traffic_directions=${traffic_directions} transaction_scale=${transaction_scale} transaction_duration=${transaction_duration} transaction_type=${transaction_type} use_latency=${use_latency} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate}
${lower} ${upper} = Display result of soak search ${average} ${stdev}
Set Test Variable \${rate for teardown} ${lower}
Should Not Be True 1.1 * ${min_rate_soft} > ${lower} Lower bound ${lower} too small for unidir minimum ${min_rate_soft}.
3.10.3.2. Find NDR and PDR intervals using optimized search¶
Find boundaries for RFC2544 compatible NDR and PDR values using an optimized search algorithm. Display findings as a formatted test message. Fail if a resulting lower bound has too high loss ratio. Input rates are unidirectional, in transaction per second. Reported result may contain aggregated pps rates, depending on test. Additional latency measurements are performed for smaller loads, even if latency stream is disabled in search. Their results are also displayed. Finally, two measurements for runtime stats are done (not displayed). Call ${resetter} (if defined) to reset DUT state before each trial. Test (or broader scope) variables read: - traffic_profile - Name of module defining traffc for measurements. Type: string - frame_size - L2 Frame Size [B] or IMIX string. Type: integer or string - max_rate - Calculated maximal unidirectional transmit rate [tps]. Type: float - resetter - Callable to reset DUT state before each trial. - transaction_scale - Number of ASTF transaction (zero if unlimited). - transaction_type - String identifier to determine how to count transactions. Default is “packet”. - disable_latency - If true, skip anything related to latency. Useful if transaction_scale is high and TPS is low. Default: false. Example: | Find NDR and PDR intervals using optimized search |
${disable_latency} = Get Disable Latency
${max_rate} = Get Max Rate
${min_rate_soft} = Get Min Rate Soft
${packet_loss_ratio} = Get Packet Loss Ratio
${ppta} = Get Packets Per Transaction Aggregated
${ramp_up_duration} = Get Ramp Up Duration
${ramp_up_rate} = Get Ramp Up Rate
${resetter} = Get Resetter
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
${use_latency} = Get Use Latency
${result} = Perform optimized ndrpdr search frame_size=${frame_size} traffic_profile=${traffic_profile} minimum_transmit_rate=${min_rate_soft} maximum_transmit_rate=${max_rate} packet_loss_ratio=${packet_loss_ratio} final_relative_width=${0.005} final_trial_duration=${30.0} initial_trial_duration=${1.0} number_of_intermediate_phases=${2} timeout=${1200.0} ppta=${ppta} resetter=${resetter} traffic_directions=${traffic_directions} transaction_duration=${transaction_duration} transaction_scale=${transaction_scale} transaction_type=${transaction_type} use_latency=${use_latency} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate}
Display result of NDRPDR search ${result}
Check NDRPDR interval validity ${result[1]} ${packet_loss_ratio}
Check NDRPDR interval validity ${result[0]}
${pdr} = Set Variable ${result[1].measured_low.target_tr}
${ndr} = Set Variable ${result[0].measured_low.target_tr}
Send traffic at specified rate rate=${pdr} trial_duration=${1.0} trial_multiplicity=${1} use_latency=${use_latency} duration_limit=${1.0}
Run Keyword If ${ndr} != ${pdr} Send traffic at specified rate rate=${ndr} trial_duration=${1.0} trial_multiplicity=${1} use_latency=${use_latency} duration_limit=${1.0}
Return From Keyword If ${disable_latency}
${rate} = Evaluate 0.9 * ${pdr}
Measure and show latency at specified rate Latency at 90% PDR: ${rate}
${rate} = Evaluate 0.5 * ${pdr}
Measure and show latency at specified rate Latency at 50% PDR: ${rate}
${rate} = Evaluate 0.1 * ${pdr}
Measure and show latency at specified rate Latency at 10% PDR: ${rate}
Measure and show latency at specified rate Latency at 0% PDR: ${0.0}
3.10.3.3. Find Throughput Using MLRsearch¶
Find and return lower bound NDR (zero PLR) throughput using MLRsearch algorithm. Input and output rates are understood as uni-directional, in tps. Call ${resetter} (if defined) to reset DUT state before each trial. Test (or broader scope) variables read: - traffic_profile - Name of module defining traffc for measurements. Type: string - frame_size - L2 Frame Size [B] or IMIX string. Type: integer or string - max_rate - Calculated maximal unidirectional transmit rate [tps]. Type: float - resetter - Callable to reset DUT state before each trial. - transaction_scale - Number of ASTF transaction (zero if unlimited). - transaction_type - String identifier to determine how to count transactions. Default is “packet”. Returns: - Lower bound for uni-directional tps throughput at given PLR. Type: float Example: | ${throughpt}= | Find Throughput Using MLRsearch |
${max_rate} = Get Max Rate
${min_rate_soft} = Get Min Rate Soft
${ppta} = Get Packets Per Transaction Aggregated
${ramp_up_duration} = Get Ramp Up Duration
${ramp_up_rate} = Get Ramp Up Rate
${resetter} = Get Resetter
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
${use_latency} = Get Use Latency
${result} = Perform optimized ndrpdr search frame_size=${frame_size} traffic_profile=${traffic_profile} minimum_transmit_rate=${min_rate_soft} maximum_transmit_rate=${max_rate} packet_loss_ratio=${0.0} final_relative_width=${0.001} final_trial_duration=${10.0} initial_trial_duration=${1.0} number_of_intermediate_phases=${1} timeout=${1200} ppta=${ppta} resetter=${resetter} traffic_directions=${traffic_directions} transaction_duration=${transaction_duration} transaction_scale=${transaction_scale} transaction_type=${transaction_type} use_latency=${use_latency} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate}
Check NDRPDR interval validity ${result[0]}
Return From Keyword ${result[0].measured_low.target_tr}
3.10.3.4. Measure and show latency at specified rate¶
Send traffic at specified rate, single trial. Extract latency information and append it to text message. The rate argument is float, so should not include “pps”. If the given rate is too low, a safe value is used instead. Call ${resetter} (if defined) to reset DUT state before each trial. Arguments: - message_prefix - Preface to test message addition. Type: string - rate - Unidirectional rate [tps] for sending packets. Type: float Example: | Measure and show latency at specified rate | Latency at 90% NDR | ${10000000} |
${min_rate_hard} = Get Min Rate Hard
${ppta} = Get Packets Per Transaction Aggregated
${ramp_up_duration} = Get Ramp Up Duration
${ramp_up_rate} = Get Ramp Up Rate
${real_rate} = Evaluate max(${rate}, ${min_rate_hard})
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
Call Resetter
Send traffic on tg duration=${PERF_TRIAL_LATENCY_DURATION} rate=${real_rate} frame_size=${frame_size} traffic_profile=${traffic_profile} async_call=${False} duration_limit=${PERF_TRIAL_LATENCY_DURATION} ppta=${ppta} traffic_directions=${traffic_directions} transaction_duration=${transaction_duration} transaction_scale=${transaction_scale} transaction_type=${transaction_type} use_latency=${True} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate}
${latency} = Get Latency Int
Set Test Message ${\n}${message_prefix} ${latency} append=${True}
Export Ndrpdr Latency ${message_prefix} ${latency}
3.10.3.5. Send ramp-up traffic¶
Fail unless positive ramp-up rate is specified. Else perform one trial with appropriate rate and duration. This is useful for tests that set DUT state via traffic. Rate has to bee low enough so packets are not lost, Duration has to be long enough to set all the state. The trial results are discarded. Test (or broader scope) variables read: - traffic_profile - Name of module defining traffic for measurements. Type: string - frame_size - L2 Frame Size [B] or IMIX string. Type: integer or string - ramp_up_duration - Suitable traffic duration [s]. Type: float - ramp_up_rate - Suitable unidirectional transmit rate [tps]. Type: float - transaction_type - String identifier to determine how to count transactions. Default is “packet”. Example: | Send ramp-up traffic |
${ramp_up_rate} = Get Ramp Up Rate
Run Keyword Unless ${ramp_up_rate} > 0.0 Fail Ramp up rate missing!
${ramp_up_duration} = Get Ramp Up Duration
${ppta} = Get Packets Per Transaction Aggregated
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
${use_latency} = Get Use Latency
Send traffic on tg duration=${ramp_up_duration} rate=${ramp_up_rate} frame_size=${frame_size} traffic_profile=${traffic_profile} async_call=${False} duration_limit=${0.0} ppta=${ppta} use_latency=${use_latency} traffic_directions=${traffic_directions} transaction_duration=${transaction_duration} transaction_scale=${transaction_scale} transaction_type=${transaction_type} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate} ramp_up_only=${True}
3.10.3.6. Send traffic at specified rate¶
Perform a warmup, show runtime counters during it. Then send traffic at specified rate, possibly multiple trials. Show various DUT stats, optionally also packet trace. Return list of measured receive rates. Call ${resetter} (if defined) to reset DUT state before each trial. Arguments: - trial_duration - Duration of single trial [s]. Type: float - rate - Target unidirectional transmit rate [tps]. Type: float Type: string - trial_multiplicity - How many trials in this measurement. Type: boolean - use_latency - Use latency stream in search; default value: False. Type: boolean - duration_limit - Hard limit for trial duration, overriding duration computed from transaction_scale. Default 0.0 means no limit. - export_mrr_unit - Use this unit when exporting MRR values, or empty string for no export. Example: | Send traffic at specified rate | ${1.0} | ${4000000.0} | ${10} | ${False} | ${1.0} | pps |
${ppta} = Get Packets Per Transaction Aggregated
${ramp_up_duration} = Get Ramp Up Duration
${ramp_up_rate} = Get Ramp Up Rate
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
Set Test Variable \${rate_for_teardown} ${rate}
Set Test Variable \${runtime_rate} ${rate}
FOR ${action} IN @{stat_runtime}
\ Run Keyword Additional Statistics Action For ${action}
FOR ${action} IN @{stat_pre_trial}
\ Run Keyword Additional Statistics Action For ${action}
${results} = Create List
FOR ${i} IN RANGE ${trial_multiplicity}
\ Call Resetter
\ ${result} = Send traffic on tg duration=${trial_duration} rate=${rate} frame_size=${frame_size} traffic_profile=${traffic_profile} async_call=${False} duration_limit=${duration_limit} ppta=${ppta} traffic_directions=${traffic_directions} transaction_duration=${transaction_duration} transaction_scale=${transaction_scale} transaction_type=${transaction_type} use_latency=${use_latency} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate}
\ ${value} = Set Variable ${result.approximated_receive_rate}
\ Append Mrr Value ${value} ${export_mrr_unit}
\ Append To List ${results} ${value}
FOR ${action} IN @{stat_post_trial}
\ Run Keyword Additional Statistics Action For ${action}
Return From Keyword ${results}
3.10.3.7. Traffic should pass with maximum rate on iPerf3¶
Send traffic at maximum rate on iPerf3. Arguments: - trial_duration - Duration of single trial [s]. Type: float - trial_multiplicity - How many trials in this measurement. Type: integer - traffic_directions - Bi- (2) or uni- (1) directional traffic; Type: integer Example: | Traffic should pass with maximum rate on iPerf3 | ${1} | | ${10.0} | ${2} |
${results}= Send iPerf3 traffic at specified rate ${trial_duration} ${None} ${None} ${trial_multiplicity} ${traffic_directions}
Set Test Message ${\n}iPerf3 trial results
Set Test Message in Gbits per second: ${results} append=yes
3.10.3.8. Send iPerf3 traffic at specified rate¶
Perform a warmup, show runtime counters during it. Then send traffic at specified rate, possibly multiple trials. Show various DUT stats, optionally also packet trace. Return list of measured receive rates. Arguments: - trial_duration - Duration of single trial [s]. Type: float - rate - Target aggregated transmit rate [bps] / Bits per second. Type: float - frame_size - L2 Frame Size [B]. Type: integer or string - trial_multiplicity - How many trials in this measurement. Type: integer - traffic_directions - Bi- (2) or uni- (1) directional traffic. Type: integer - extended_debug - True to enable extended debug. Type: boolean Example: | Send iPerf3 traffic at specified rate | ${1.0} | ${4000000.0} | ${64} | ${10} | ${1} | ${False} |
Set Test Variable ${extended_debug}
Set Test Variable ${rate}
Set Test Variable ${traffic_directions}
${smt_used}= Is SMT enabled ${nodes['${iperf_server_node}']['cpuinfo']}
${vm_status} ${value}= Run Keyword And Ignore Error Get Library Instance vnf_manager
${vth}= Evaluate (${dp_count_int} + 1)
${cpu_skip_cnt}= Set Variable If '${vm_status}' == 'PASS' ${CPU_CNT_SYSTEM} ${${CPU_CNT_SYSTEM} + ${CPU_CNT_MAIN} + ${cpu_count_int} + ${vth}}
Initialize iPerf Server ${nodes['${iperf_server_node}']} pf_key=${iperf_server_pf_key} interface=${iperf_server_interface} bind=${iperf_server_bind} bind_gw=${iperf_server_bind_gw} bind_mask=${iperf_server_bind_mask} namespace=${iperf_server_namespace} cpu_skip_cnt=${cpu_skip_cnt}
Run Keyword If '${iperf_client_namespace}' != '${None}' Set Linux Interface IP ${nodes['${iperf_client_node}']} interface=${iperf_client_interface} ip_addr=${iperf_client_bind} prefix=${iperf_client_bind_mask} namespace=${iperf_client_namespace}
Run Keyword If '${iperf_client_namespace}' != '${None}' Add Default Route To Namespace ${nodes['${iperf_client_node}']} namespace=${iperf_client_namespace} default_route=${iperf_client_bind_gw}
${stat_runtime}= Create List vpp-runtime-iperf3
${stat_pre_trial}= Create List vpp-runtime-iperf3 vpp-clear-stats vpp-enable-packettrace
FOR ${action} IN @{stat_runtime}
\ Run Keyword Additional Statistics Action For ${action}
FOR ${action} IN @{stat_pre_trial}
\ Run Keyword Additional Statistics Action For ${action}
${results} = Create List
FOR ${i} IN RANGE ${trial_multiplicity}
\ ${rr} = iPerf Client Start Remote Exec ${nodes['${iperf_client_node}']} duration=${trial_duration} rate=${rate} frame_size=${frame_size} async_call=False warmup_time=0 traffic_directions=${traffic_directions} namespace=${iperf_client_namespace} udp=${iperf_client_udp} host=${iperf_server_bind} bind=${iperf_client_bind} affinity=${iperf_client_affinity}
\ ${conv} = Convert To Number ${rr['sum_received']['bits_per_second']}
\ ${conv} = Evaluate ${conv} / ${1000} / ${1000} / ${1000}
\ ${conv} = Evaluate "{:.3f}".format(${conv})
\ Append To List ${results} ${conv}
FOR ${action} IN @{stat_post_trial}
\ Run Keyword Additional Statistics Action For ${action}
Return From Keyword ${results}
3.10.3.9. Start Traffic on Background¶
Start traffic at specified rate then return control to Robot. This keyword is useful if the test needs to do something while traffic is running. Test (or broader scope) variables read: - traffic_profile - Name of module defining traffc for measurements. Type: string - frame_size - L2 Frame Size [B] or IMIX string. Type: integer or string Arguments: - rate - Unidirectional rate [tps] for sending packets. Type: float Example: | Start Traffic on Background | ${4000000.0} |
${ppta} = Get Packets Per Transaction Aggregated
${ramp_up_duration} = Get Ramp Up Duration
${ramp_up_rate} = Get Ramp Up Rate
${traffic_directions} = Get Traffic Directions
${transaction_duration} = Get Transaction Duration
${transaction_scale} = Get Transaction Scale
${transaction_type} = Get Transaction Type
${use_latency} = Get Use Latency
Call Resetter
Send traffic on tg duration=${-1} rate=${rate} frame_size=${frame_size} traffic_profile=${traffic_profile} async_call=${True} duration_limit=${0.0} ppta=${ppta} ramp_up_duration=${ramp_up_duration} ramp_up_rate=${ramp_up_rate} traffic_directions=${traffic_directions} transaction_duration=${transaction_duration} transaction_scale=${transaction_scale} transaction_type=${transaction_type} use_latency=${use_latency}
3.10.3.10. Stop Running Traffic¶
Stop the running traffic, return measurement result. For bidirectional traffic, the reported values are bi-directional. Returns: - Measurement result. Type: ReceiveRateMeasurement Example: ${result}= | Stop Running Traffic |
${result}= Stop traffic on tg
Return From Keyword ${result}
3.10.3.11. Traffic should pass with maximum rate¶
Send traffic at maximum rate. Call ${resetter} (if defined) to reset DUT state before each trial. Fail if no packets were forwarded. Test (or broader scope) variables read: - traffic_profile - Name of module defining traffic for measurements. Type: string - frame_size - L2 Frame Size [B] or IMIX string. Type: integer or string - max_rate - Calculated maximal transmit rate [tps]. Type: float - transaction_type - String identifier to determine how to count transactions. Default is “packet”. Example: | Traffic should pass with maximum rate |
${max_rate} = Get Max Rate
${transaction_type} = Get Transaction Type
${trial_duration} = Get Mrr Trial Duration
${trial_multiplicity} = Get Mrr Trial Multiplicity
${use_latency} = Get Use Latency
${unit} = Set Variable If """_cps""" in """${transaction_type}""" cps pps
${results} = Send traffic at specified rate rate=${max_rate} trial_duration=${trial_duration} trial_multiplicity=${trial_multiplicity} use_latency=${use_latency} duration_limit=${0.0} export_mrr_unit=${unit}
${unit_text} = Set Variable If """_cps""" in """${transaction_type}""" estimated connections per second packets per second
Set Test Message ${\n}Maximum Receive Rate trial results
Set Test Message in ${unit_text}: ${results} append=yes
Fail if no traffic forwarded
3.10.4. performance_vars suite¶
3.10.4.1. Get Disable Latency¶
If Get Use Latency returns true, return false. Otherwise return value of ${disable_latency} variable, or ${False} if not defined. The return value controls whether latency trials in NDRPDR tests are executed. For example, ASTF tests do not support latency measurements yet, so executing the trials just wastes time. Return type: bool. Example: | ${disable_latency} = | Get Disable Latency |
${use_latency} = Get Use Latency
Return From Keyword If ${use_latency} ${False}
${disable_latency} = Get Variable Value \${disable_latency} ${False}
Return From Keyword ${disable_latency}
3.10.4.2. Get Max Rate¶
Return value of ${max_rate} variable, fail if it is not defined. Call this just before calling a Python keyword, as those have restricted access to Robot variables. The return value controls the maximal unidirectional packet rate. The value is also usable for minimal TPS value for ASTF tests. Return type: float. Example: | ${max_rate} = | Get Max Rate |
${max_rate} = Get Variable Value \${max_rate} ${0.0}
Return From Keyword If ${max_rate} ${max_rate}
Fail \${max_rate} is not defined. Call Set Max Rate And Jumbo keyword.
3.10.4.3. Get Min Rate Hard¶
Return a hardcoded value. The return value controls the minimal unidirectional packet rate, to be used anywhere, including latency measurements at 0% load. The current value is the smallest one permitted by STL profiles with latency streams. Return type: float. Example: | ${min_rate_hard} = | Get Min Rate Hard |
Return From Keyword ${9001.0}
3.10.4.4. Get Min Rate Soft¶
If ramp up rate is not defined, return the hard min value. If ramp up rate is defined (and larger than hard min), return that. The reason is, ramp up rate should already guarantee no loss. The return value controls the minimal unidirectional packet rate, to be used in various search algorithms. Latency measurements may want even lower loads, use hard min for that. The value is also usable for minimal TPS value for ASTF tests. Return type: float. Currently, undefined ramp up rate is reported as zero, so we return the maximum of ramp up rate and the hard min rate. Example: | ${min_rate_soft} = | Get Min Rate Soft |
${min_rate_hard} = Get Min Rate Hard
${ramp_up_rate} = Get Ramp Up Rate
${min_rate_soft} = Evaluate max(${ramp_up_rate}, ${min_rate_hard})
Return From Keyword ${min_rate_soft}
3.10.4.5. Get Mrr Trial Duration¶
Return value from Constants. This is an abstraction, useful in case we start allowing various other overrides or computations. Call this just before calling a Python keyword, as those have restricted access to Robot variables. The return value controls the duration of main trial measurement for MRR type tests. Return type: float. Example: | ${mrr_trial_duration} = | Get Mrr Trial Duration |
Return From Keyword ${PERF_TRIAL_DURATION}
3.10.4.6. Get Mrr Trial Multiplicity¶
Return value from Constants. This is an abstraction, useful in case we start allowing various other overrides or computations. Call this just before calling a Python keyword, as those have restricted access to Robot variables. The return value controls the number of main trial measurement for (B)MRR type tests. Return type: integer. Example: | ${mrr_trial_multiplicity} = | Get Mrr Trial Multiplicity |
Return From Keyword ${PERF_TRIAL_MULTIPLICITY}
3.10.4.7. Get Packet Loss Ratio¶
Return a hardcoded value. This is an abstraction, useful in case we start allowing various other overrides or computations. Call this just before calling a Python keyword, as those have restricted access to Robot variables. The return value controls the default packet loss ration for PDR in NDRPDR tests. Some other usages of MLRsearch (e.g. reconf tests) may use a different value. Return type: float. Example: | ${packet_loss_ratio} = | Get Packet Loss Ratio |
Return From Keyword ${0.005}
3.10.4.8. Get Packets Per Transaction Aggregated¶
Return value of ${packets_per_transaction_aggregated}; if not defined, assume traffic is symmetric (or unidirectional) and compute from unidirectional values. The return value is used when reporting PPS (and bandwidth) values from TPS found by some search (e.g. NDRPDR). Return type: integer. Example: | ${ppta} = | Get Packets Per Transaction Aggregated |
${ppta} = Get Variable Value \${packets_per_transaction_aggregated} ${0}
Return From Keyword If "${ppta}" != "0" ${ppta}
${pptad} = Get Packets Per Transaction And Direction
${traffic_directions} = Get Traffic Directions
${ppta} = Evaluate ${pptad} * ${traffic_directions}
Return From Keyword ${ppta}
3.10.4.9. Get Packets Per Transaction And Direction¶
Return value of ${packets_per_transaction_and_direction}, or ${1} if not defined. The return value is used when computing max rate (TPS) from packet level (pps or bps) limits. For asymmetric transactions, use the more numerous direction. Return type: integer. Example: | ${pptad} = | Get Packets Per Transaction And Direction |
${pptad} = Get Variable Value \${packets_per_transaction_and_direction} ${1}
Return From Keyword ${pptad}
3.10.4.10. Get Ramp Up Duration¶
Return value of ${ramp_up_duration}, or ${0.0} if not defined. The return value determines the required duration of ramp-up phase. Typically used to prepare a specific state on DUT. If the value is zero, ramp-up phase is either skipped or size-limited. Return type: float. Example: | ${ramp_up_duration} = | Get Ramp Up Duration |
${ramp_up_duration} = Get Variable Value \${ramp_up_duration} ${0.0}
Return From Keyword ${ramp_up_duration}
3.10.4.11. Get Ramp Up Rate¶
Return value of ${ramp_up_rate}, if not defined, return zero. The return value determines the rate for ramp-up phase. Typically used to limit the rate when max rate would lose packets in the ramp up phase, thus not setting the DUT state correctly. If the value is zero, ramp-up phase should be skipped. Return type: float. Example: | ${ramp_up_rate} = | Get Ramp Up Rate |
${ramp_up_rate} = Get Variable Value \${ramp_up_rate} ${0.0}
Return From Keyword ${ramp_up_rate}
3.10.4.12. Get Rate For Teardown¶
Return value of ${rate_for_teardown}, if not defined (or zero) return the soft min rate. The return value determines the rate for teardown trial, that is executed if a perf test fails. The ${rate_for_teardown} is usually not defined in suite, but search keywords set it in places where failure can occur, so the trial is done at the rate interesting for the failure. Return type: float. Example: | ${rate_for_teardown} = | Get Rate For Teardown |
${rate_for_teardown} = Get Variable Value \${rate_for_teardown} ${0.0}
Return From Keyword If ${rate_for_teardown} ${rate_for_teardown}
Run Keyword And Return Get Min Rate Soft
3.10.4.13. Get Resetter¶
Return value of ${resetter} variable, or ${None} if not defined. If not ${None}, the returned value is callable. Its use is to reset DUT to initial conditions, for example to remove NAT sessions created in the previous trial. Example: | ${resetter} = | Get Resetter |
${resetter} = Get Variable Value \${resetter} ${None}
Return From Keyword ${resetter}
3.10.4.14. Get Runtime Duration¶
Return value of ${runtime_duration} variable, if not defined return ${1.0}. The return value controls the duration of runtime trial, which also acts as a warmup. Usually one second is enough, but some suites need longer time to set up state on DUT. Return type: float. Example: | ${runtime_duration} = | Get Runtime Duration |
${runtime_duration} = Get Variable Value \${runtime_duration} ${1.0}
Return From Keyword ${runtime_duration}
3.10.4.15. Get Runtime Rate¶
Return value of ${runtime_rate} variable, if not defined return the max rate. The return value controls the rate (TPS unidir) of runtime trial, which also acts as a warmup. No plans to ever use a different rate, but keywords look better if access to such values is uniform. Return type: float. Example: | ${runtime_rate} = | Get Runtime Rate |
${runtime_rate} = Get Variable Value \${runtime_rate} ${0.0}
Return From Keyword If ${runtime_rate} ${runtime_rate}
Run Keyword And Return Get Max Rate
3.10.4.16. Get Traffic Directions¶
Return value of ${traffic_directions}, or ${2} if not defined. The return value used when parsing for measurement results. This needs to be known already in profile driver, as bidirectional parsing may fail on unidirectional traffic. Return type: integer. Example: | ${traffic_directions} = | Get Traffic Directions |
${traffic_directions} = Get Variable Value \${traffic_directions} ${2}
Return From Keyword ${traffic_directions}
3.10.4.17. Get Transaction Duration¶
Return value of ${transaction_duration} variable, or ${0.0} if not defined. The return value is the expected duration of single (ASTF) transaction if it is not negligible for overall trial duration computation. Most tests use very short transactions (without explicit delays), so the zero default works (and suite saves one line of Variables table). Return type: float. Example: | ${transaction_duration} = | Get Transaction Duration |
${transaction_duration} = Get Variable Value \${transaction_duration} ${0.0}
Return From Keyword ${transaction_duration}
3.10.4.18. Get Transaction Scale¶
Return value of ${transaction_scale} variable, or ${0} if not defined. Zero return value means the number of transactions is not limited, which is true for most STL TRex profiles (transaction is a packet). Nonzero return value means the number of transactions is fixed, for example in stateful NAT scale tests. Return type: integer. Example: | ${transaction_scale} = | Get Transaction Scale |
${transaction_scale} = Get Variable Value \${transaction_scale} ${0}
Return From Keyword ${transaction_scale}
3.10.4.19. Get Transaction Type¶
Return value of ${transaction_type} variable, or “packet” if not defined. The return value describes the type of transaction the test is executed. For example “packet” means a transaction is just a single packet. For more sophisticated transactions, the logic to determine the number of passed transactions is different from merely counting the packets received from DUT. Return type: string. Example: | ${transaction_type} = | Get Transaction Type |
${transaction_type} = Get Variable Value \${transaction_type} packet
Return From Keyword ${transaction_type}
3.10.4.20. Get Use Latency¶
Return value of ${use_latency} variable, if not defined return the value from Constants. The return value controls whether latency streams are active during the main search. Return type: bool. Example: | ${use_latency} = | Get Use Latency |
${use_latency} = Get Variable Value ${use_latency} ${PERF_USE_LATENCY}
Return From Keyword ${use_latency}
3.10.4.21. Set Jumbo¶
Call Set Numeric Frame Sizes and set jumbo based on max framesize. To streamline suite autogeneration, both input and output values are communicated as test (or broader scope) variables, instead of explicit arguments and return values. Test (or broader scope) variables read: - overhead - Overhead in bytes; default value: 0. Type: integer - frame_size - Framesize. Type: integer or string Test variables set: - jumbo - Jumbo boolean, true if jumbo packet support has to be enabled. Type: boolean Example: | Set Jumbo |
Set Numeric Frame Sizes
${jumbo} = Evaluate ${max_frame_size} >= 1522
Set Test Variable \${jumbo}
3.10.4.22. Set Max Rate And Jumbo¶
This keyword computes maximal unidirectional transmit rate and jumbo boolean (some suites need that for configuration decisions). To streamline suite autogeneration, both input and output values are communicated as test (or broader scope) variables, instead of explicit arguments and return values. For correctly applying bandwidth limit, average frame size is used, see Set Numeric Frame Sizes keyword documentation for details. If this keyword detects the test is interested in (unidirectional) transactons per second maximal rate (tps), that is returned (not pps). Test (or broader scope) variables read: - nic_name - Name of bottleneck NIC. Type: string - overhead - Overhead in bytes; default value: 0. Type: integer - frame_size - L2 Frame Size [B] or IMIX string. Type: integer or string - ASTF_N_DATA_FRAMES - Number of data frames per transaction and direction. Type: integer - packets_per_transaction_and_direction - May be unset. See Get Packets Per Transaction And Direction keyword. Type: integer - packets_per_transaction_aggregated - May be unset. See Get Packets Per Transaction Aggregated keyword. Type: integer - TEST_TAGS - Robot tags of this test. Type: list of string Test variables set: - max_rate - Calculated unidirectional maximal transmit rate [pps]. This never exceeds bandwidth on TG-DUT nor DUT-DUT links. Type: float - jumbo - Jumbo boolean, true if jumbo packet support has to be enabled. Type: boolean - max_frame_size - Maximal frame size including overhead. Type: float - avg_directional_frame_size - Average frame size including overhead for the more loaded direction. Type: float - avg_aggregated_frame_size - Average frame size including overhead across both traffic directions. Type: float Example: | Set Max Rate And Jumbo |
${pps_limit} = Get From Dictionary ${NIC_NAME_TO_PPS_LIMIT} ${nic_name}
${bps_limit} = Get From Dictionary ${NIC_NAME_TO_BPS_LIMIT} ${nic_name}
Set Jumbo
${adfs} = Get Variable Value \${avg_directional_frame_size}
${rate} = Evaluate ${bps_limit} / ((${adfs} + 20.0) * 8)
${max_rate} = Set Variable If ${rate} > ${pps_limit} ${pps_limit} ${rate}
${pptad} = Get Packets Per Transaction And Direction
${max_rate} = Evaluate ${max_rate} / ${pptad}
Set Test Variable \${max_rate}
3.10.4.23. Set Numeric Frame Sizes¶
Framesize can be either integer in case of a single packet in stream, or set of packets in case of IMIX type or simmilar. For jumbo decisions, we need a numeric size of the biggest packet. For bandwidth limit decisions, we need a numeric average packet size in the more bit intensive direction if traffic is non-symmetric. Computation of max_rate assumes it is also the more pps direction (so it can have smaller average frame size than the aggregated one). Average (across both directions) frame size is also used for displaying the bidirectional bandwidth forwarded. This keyword computes all three values (accounting for overheads) and sets them as test variables. Each suite sets a value named ${overhead}, which describes by how many bytes the frames on DUT-DUT link are larger (due to encapsulation) than those on the primary TG-DUT link. For some suites that value can be negaive (if TG-DUT is encapsulated more heavily). For calculations in this keyword, we need largest sizes across links, so zero is used if ${overhead} is negative. The other overhead is from TCP control packets (only IPv4 supported). TCP_CPS tests have SYN frames of length 78B and other frames 70B. The more loaded is client-to-server direction with 1 SYN and 3 other, across both directions it is 2 SYN and 5 other. TCP_PPS and TCP_TPUT tests have one other control packet less (in the less loaded direction), but they do contain data frames. Test variables read: - frame_size - Framesize. Type: integer or string - overhead - Overhead in bytes; default value: ${0}. Type: integer - ASTF_N_DATA_FRAMES - Number of data frames per transaction and direction. Type: integer - packets_per_transaction_and_direction - May be unset. See Get Packets Per Transaction And Direction keyword. Type: integer - packets_per_transaction_aggregated - May be unset. See Get Packets Per Transaction Aggregated keyword. Type: integer - TEST_TAGS - Robot tags of this test. Type: list of string Test variables set - max_frame_size - Maximal frame size including overhead. Type: float - avg_directional_frame_size - Average frame size including overhead for the more loaded direction. Type: float - avg_aggregated_frame_size - Average frame size including overhead across both traffic directions. Type: float Example: | Set Numeric Frame Sizes |
${bare_max_frame_size} = Run Keyword If '${frame_size}' == 'IMIX_v4_1' Set Variable ${1518.0} ELSE Convert To Number ${frame_size}
${bafs} = Run Keyword If '${frame_size}' == 'IMIX_v4_1' Set Variable ${353.8333333333333} ELSE Convert To Number ${frame_size}
${is_cps} = Evaluate 'TCP_CPS' in ${TEST_TAGS}
${is_pps} = Evaluate 'TCP_PPS' in ${TEST_TAGS}
${is_tput} = Evaluate ${is_pps} or 'TCP_TPUT' in ${TEST_TAGS}
${is_cps} = Evaluate ${is_cps} and 'HOSTSTACK' not in ${TEST_TAGS}
${is_tput} = Evaluate ${is_tput} and 'HOSTSTACK' not in ${TEST_TAGS}
${avg_dir_frame_size} ${avg_agg_frame_size} = Run Keyword If ${is_cps} Apply Tcp Cps Proto Overhead ${bafs} ELSE IF ${is_tput} Apply Tcp Tput Proto Overhead ${bafs} ELSE Set Variable ${bafs} ${bafs}
${max_overhead} = Set Variable If ${overhead} >= 0 ${overhead} ${0}
${mfs} = Evaluate ${bare_max_frame_size} + ${max_overhead}
${adfs} = Evaluate ${avg_dir_frame_size} + ${max_overhead}
${aafs} = Evaluate ${avg_agg_frame_size} + ${max_overhead}
Set Test Variable \${max_frame_size} ${mfs}
Set Test Variable \${avg_directional_frame_size} ${adfs}
Set Test Variable \${avg_aggregated_frame_size} ${aafs}
3.10.4.24. Apply Tcp Cps Proto Overhead¶
Recompute average frame size for TCP CPS test cases. This is contitionally called from Set Numeric Frame Sizes. In Robot Framework it is more convenient to wrap such a block as a standalone keyword to Run Keyword If. Test variables read: - ASTF_N_DATA_FRAMES - Number of data frames per transaction and direction. Usually set globally. Type: integer - packets_per_transaction_and_direction - May be unset. See Get Packets Per Transaction And Direction keyword. Type: integer - packets_per_transaction_aggregated - May be unset. See Get Packets Per Transaction Aggregated keyword. Type: integer Arguments: - bare_avg_frame_size - Average numeric framesize without overheads. Returns: - avg_dir_frame_size - Average framesize for more loaded direction. - avg_agg_frame_size - Average framesize across both directions. Example: | ${adfs} | ${aafs} = | Apply Tcp Cps Proto Overhead | ${bafs}
Run Keyword If ${bare_avg_frame_size} != 64 Fail TCP_CPS tests are only supported for (nominal) 64B frames.
${pptad} = Get Packets Per Transaction And Direction
${ppta} = Get Packets Per Transaction Aggregated
${avg_dir_frame_size} = Evaluate (78.0 * 1 + 70.0 * 3) / (1 + 3)
Run Keyword If '${pptad}' != '4' Fail TCP CPS with pptad '${pptad}' != '4'.
${avg_agg_frame_size} = Evaluate (78.0 * 2 + 70.0 * 5) / (2 + 5)
Run Keyword If '${ppta}' != '7' Fail TCP CPS with ppta '${ppta}' != '7'.
Return From Keyword ${avg_dir_frame_size} ${avg_agg_frame_size}
3.10.4.25. Apply Tcp Tput Proto Overhead¶
Recompute average frame size for TCP TPUT (or PPS) test cases. This is contitionally called from Set Numeric Frame Sizes. In Robot Framework it is more convenient to wrap such a block as a standalone keyword to Run Keyword If. Test variables read: - ASTF_N_DATA_FRAMES - Number of data frames per transaction and direction. Usually set globally. Type: integer - packets_per_transaction_and_direction - May be unset. See Get Packets Per Transaction And Direction keyword. Type: integer - packets_per_transaction_aggregated - May be unset. See Get Packets Per Transaction Aggregated keyword. Type: integer Arguments: - bare_framesize - Average numeric framesize without overheads. Returns: - avg_dir_frame_size - Average framesize for more loaded direction. - avg_agg_frame_size - Average framesize across both directions. Example: | ${adfs} | ${aafs} = | Apply Tcp Cps Proto Overhead | ${bafs}
${pptad} = Get Packets Per Transaction And Direction
${ppta} = Get Packets Per Transaction Aggregated
${numerator} = Evaluate ${bare_framesize} * ${ASTF_N_DATA_FRAMES}
${numerator} = Evaluate 78.0 * 1 + 70.0 * 3 + ${numerator}
${denominator} = Evaluate 1 + 3 + ${ASTF_N_DATA_FRAMES}
${avg_dir_frame_size} = Evaluate ${numerator} / ${denominator}
Run Keyword If '${pptad}' != '${denominator}' Fail TCP TPUT with pptad '${pptad}' != '${denominator}'.
${numerator} = Evaluate ${bare_framesize} * 2 * ${ASTF_N_DATA_FRAMES}
${numerator} = Evaluate 78.0 * 2 + 70.0 * 4 + ${numerator}
${denominator} = Evaluate 2 + 4 + 2 * ${ASTF_N_DATA_FRAMES}
${avg_agg_frame_size} = Evaluate ${numerator} / ${denominator}
Run Keyword If '${ppta}' != '${denominator}' Fail TCP TPUT with ppta '${ppta}' != '${denominator}'.
Return From Keyword ${avg_dir_frame_size} ${avg_agg_frame_size}
3.10.4.26. Set Rates For Policer¶
Policer tests need these values, currently computed from ${avg_directional_frame_size}. TODO: Verify the units match and computation is correct. Test (or broader scope) variables read: - avg_directional_frame_size - Average L2 Frame Size [B]. Type: float Set by Set Max Rate And Jumbo keyword. Test variables set: - eb - Excess burst rate for policer. Type: float - cb - Committed burst rate for policer. Type: float Example: | Set Rates For Policer |
Set Test Variable \${eb} ${avg_directional_frame_size}
Set Test Variable \${cb} ${avg_directional_frame_size}