RFC 8239 Functions

sth::test_rfc8239_config

Purpose

The sth::test_rfc8239_config command creates, modifies, and deletes a line-rate test. The RFC 8239 tests are used to establish test and evaluation methodology and measurement techniques for physical network equipment in the data center.

Synopsis

Note

M indicates that the argument is Mandatory .

sth::test_rfc8239_config
   [-mode {create|modify|delete}  M]
   [-handle <test_handle>]
   [-src_port <port_handle>]
   [-dst_port <port_handle>]
   [-endpoint_creation {0|1}]
   [-device_count <integer>]
   [-mac_addr {aa:bb:cc:dd:ee:ff}]
   [-port_mac_step {aa:bb:cc:dd:ee:ff}]
   [-device_mac_step {aa:bb:cc:dd:ee:ff}]
   [-vlan <integer>]
   [-port_vlan_step <integer>]
   [-device_vlan_step <integer>]
   [-vlan_priority <1-7>]
   [-ipv4_addr <a.b.c.d>]
   [-port_ipv4_addr_step <a.b.c.d>]
   [-device_ipv4_addr_step <a.b.c.d>]
   [-ipv4_prefix_len <1-32>]
   [-ipv4_gateway <a.b.c.d>]
   [-port_ipv4_gateway_step <a.b.c.d>]
   [-ipv6_addr <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>]
   [-port_ipv6_addr_step <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>]
   [-device_ipv6_addr_step <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>]
   [-ipv6_prefix_len <0-128>]
   [-ipv6_gateway <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>]
   [-port_ipv6_gateway_step <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>]
   [-qos <string>]
   [-src_endpoints <handle>]
   [-dst_endpoints <handle>]
   [-streamblock_handle <handle>]
   [-traffic_pattern {pair|mesh|backbone}]
   [-enable_stream_only_gen {1|0}]
   [-endpoint_map {one_to_one|one_to_many}]
   [-bidirectional {0|1}]
   [-iteration_count {integer}]
   [-test_duration_mode {seconds|bursts}]
   [-test_duration_seconds <integer>]
   [-test_duration_bursts <integer>]
   [-test_type {lr|mb}]
   [-streamblock_frame_sizes {true|false}]
   [-frame_size_mode {custom|random|step|imix}]
   [-frame_size <integer>]
   [-frame_size_imix <string>]
   [-frame_size_start <integer>]
   [-frame_size_end <integer>]
   [-frame_size_step <integer>]
   [-frame_size_min <integer>]
   [-frame_size_max <integer>]
   [-load_type {custom|random|step|fixed}]
   [-load_unit {bits_per_second|frames_per_second|inter_burst_gap|
        kilobits_per_second|megabits_per_second|percent_line_rate }]
   [-load_list <list_value>]
   [-load_start <integer>]
   [-load_end <integer>]
   [-load_step <integer>]
   [-load_min <integer>]
   [-load_max <integer>]
   [-load_fixed <integer>]
   [-burst_type {custom|fixed|step}]
   [-burst_list <list_value>]
   [-burst_fixed <integer>]
   [-burst_start <integer>]
   [-burst_end <integer>]
   [-burst_step <integer>]
   [-burst_inter_frame_gap <integer>]
   [-latency_distribution_list <integer>]
   [-latency_type {FILO|FIFO}]
   [-start_traffic_delay <0-3600>]
   [-stagger_start_delay <0-65>]
   [-delay_after_transmission <0-3600>]
   [-enable_learning {0|1}]
   [-learning_mode {l2|l3}]
   [-learning_frequency {learn_once|learn_every_trial|
        learn_every_frame_size|learn_every_iteration}]
   [-learning_rate <integer>]
   [-l3_learning_retry_count <1-100>]
   [-l2_learning_repeat_count <1-100>]
   [-l2_delay_before_learning <0-3600>]
   [-l3_delay_before_learning <0-3600>]
   [-l2_fixed_frame_size <integer>]
   [-l2_learning_frame_size_mode {same_as_test|fixed}]
   [-enable_cyclic_resolution {0|1}]
   [-enable_traffic_verification {true|false}]
   [-traffic_verification_freq_mode {verify_every_trial|
                      verify_every_frame_size|verify_every_iteration}]
   [-traffic_verification_abort_on_fail {true|false}]
   [-traffic_verification_tx_frame_count <1-32767>]
   [-traffic_verification_tx_frame_rate <1-14880952>]
   [-display_load_unit {bits_per_second|frames_per_second|inter_burst_gap|
                         kilobits_per_second|megabits_per_second|
                         percent_line_rate}]

Arguments

-mode

Specify the action to be performed on the test port. This argument is Mandatory . Possible values are create, modify, and delete. The values are described below:

create - Creates a Line-Rate test.

modify - Modifies the configuration for the created test.

delete - Deletes the created test.
-src_port

Defines the source port to be used for stream creation. You can use this argument when -endpoint_creation is set to 1.

-dst_port

Defines the destination port to be used for stream creation. You can use this argument when -endpoint_creation is set to 1.

-handle

Specifies the test to be modified or deleted. This argument is Mandatory for modify mode and delete mode.

-endpoint_creation

Determines whether Spirent HLTAPI creates new endpoints on the ports specified by -src_port and -dst_port. The endpoints are used to create new streams in the test. Possible values are 0 and 1. When it is set to 1, Spirent HLTAPI creates new endpoints on the given source port and destination port. You must specify the -src_port argument and the -dst_port argument when the value is 1. When it is set to 0, you can create streams in two other ways. One is to specify -src_endpoints and -dst_endpoints, and then this command will create a bound stream for the test; the other is to provide a list of existing streams (-streamblock_handle), which the command will use for the test.

-device_count

Defines the number of devices you can create on each port. The default value is 1. This argument is only valid when the -endpoint_creation argument is set to 1.

-mac_addr

The starting MAC address to use when emulating devices. You can use this argument when -endpoint_creation is set to 1. The value should be in MAC address format.

-port_mac_step

Defines the step size to be used for incrementing MAC addresses across ports. You can use this argument when -endpoint_creation is set to 1.

-device_mac_step

Defines the step value to be used for incrementing MAC address across devices on one port. You can use this argument when -endpoint_creation is set to 1. The value should be in MAC address format.

-vlan

Specifies the VLAN ID for the first device. You can use this option when -endpoint_creation is set to 1.

-port_vlan_step

Defines the step value to be used for incrementing VLAN IDs across the ports. You can use this argument when -endpoint_creation is set to 1.

-device_vlan_step

Specifies the step value to be used for incrementing VLAN IDs across the devices on one port. You can use this argument when -endpoint_creation is set to 1.

-vlan_priority

Specifies the VLAN priority for created devices. Possible values range from 1 to 7. You can use this argument when -endpoint_creation is set to 1.

-ipv4_addr

Defines the first IPv4 address when emulating devices. You can use this argument when -endpoint_creation is set to 1. The value should be in IPv4 format.

-port_ipv4_addr_step

Defines the step value to be used for incrementing IPv4 addresses across the ports. You can use this argument when -endpoint_creation is set to 1. The value should be in the IPv4 format. For example, if you specify -port_ipv4_addr_step 0.1.0.0, -ipv4_addr 192.85.1.2, and -device_ipv4_addr_step 0.0.0.1. When there are two ports, the IPv4 addresses for emulating hosts are listed below:

First host block: 192.85.1.2, 192.85.1.3, 192.85.1.4...
Second host block: 192.86.1.2, 192.86.1.3, 192.86.1.4...

The number of hosts in each host block is specified by the -device_count argument.

-device_ipv4_addr_step

Defines the step value to be used for incrementing IPv4 addresses across the devices on one port. You can use this argument when -endpoint_creation is set to 1.

-ipv4_prefix_len

Specifies the IPv4 prefix length for created devices. You can use this argument when -endpoint_creation is set to 1.

-ipv4_gateway

Specifies the IPv4 gateway addresses for the first device. You can use this argument when -endpoint_creation is set to 1. The value should be in IPv4 format.

-port_ipv4_gateway_step

Specifies the step value to be used for incrementing IPv4 gateway addresses across the ports. You can use this argument when -endpoint_creation is set to 1. The value should be in IPv4 format.

-ipv6_addr

Specifies the first IPv6 address when creating devices. You can use this argument when -endpoint_creation is set to 1. The value should be in IPv6 format.

-port_ipv6_addr_step

Specifies the step size to be used for incrementing IPv6 addresses across the ports. You can use this argument when -endpoint_creation is set to 1. The value should be in IPv6 format.

-device_ipv6_addr_step

Defines the step value to be used for incrementing IPv6 addresses across the devices on one port. You can use this argument when -endpoint_creation is set to 1. The value should be in IPv6 format.

-ipv6_prefix_len

Specifies the prefix length of the IPv6 addresses. You can use this argument when -endpoint_creation is set to 1. Possible values range from 0 to128.

-ipv6_gateway

Defines the starting IPv6 gateway address when emulating devices. You can use this argument when -endpoint_creation is set to 1. The value should be in IPv6 format.

-port_ipv6_gateway_step

Specifies the step size to be used for incrementing IPv6 gateway address across the port. You can use this argument when -endpoint_creation is set to 1. The value should be in IPv6 format.

-qos

Specifies a list of Quality of Service (QoS) parameters. The default value is 0.

-src_endpoints

Specifies the source endpoint used to create traffic. The trial will use the traffic binding to the source endpoint (-src_endpoints) and the destination endpoint (-dst_endpoints) to run. When you specify this argument, you must specify the -dst_endpoints option. You can use this argument when the -endpoint_creation option is set to 0. This value can be an endpoint or a list of endpoints.

-dst_endpoints

Specifies the destination endpoint used to create traffic. The trial will use the traffic binding to the source endpoint (-src_endpoints) and the destination endpoint (-dst_endpoints) to run. When you specify this argument, you must specify the -src_endpoints option. You can use this argument when the -endpoint_creation option is set to 0. This value can be an endpoint or a list of endpoints.

-streamblock_handle

Indicates the existing streams used for the test. The trial will use the provided streamblock to do the test. The value of this argument can be a stream or a list of streams. You can use this argument when the -endpoint_creation option is set to 0.

-traffic_pattern

Indicates the traffic pattern to be used for the test. Possible values are pair, mesh, and backbone. The patterns are described below:

pair - Traffic is transmitted between one or more port pairs.
      The ports to use is specified by the -src_endpoints
      option and the -dst_endpoints option.

mesh - Every port transmits traffic to every other port and
      receives traffic from all other ports simultaneously.
      -src_endpoints and -dst_endpoints are the endpoints to be
      included in the fully meshed network.

backbone - Traffic is transmitted in a partially meshed pattern,
       either unidirectional or bidirectional. -src_endpoints and
       -dst_endpoints are the endpoints to be included in
       the backbone network.
-enable_stream_only_gen

Disables or enables the stream only generation option when creating traffic. When it is set to 1, Spirent TestCenter will generate a separate stream for each flow instead of generating the same stream for all flows. Possible values are 0 and 1. The default is 1.

-endpoint_map

Specifies one of the following traffic mapping methods to be used within each host block. Possible values are one_to_one and one_to_many. The methods are described below:

one_to_one - Every endpoint within the source endpoint
    block transmits traffic to the corresponding destination
    endpoint within the destination endpoint block.

one_to_many - Every endpoint within the source endpoint
    block transmits traffic to every destination endpoint
    within the destination endpoint block.
-bidirectional

Determines whether the traffic is unidirectional or bidirectional. Possible values are 0 (unidirectional) and 1 (bidirectional).

-iteration_count

Specifies the number of times the test repeats with its initial configuration. Each trial is based on the same parameter values. Within a trial, certain parameter values vary with each iteration, according to the test methodology and setup. At the start of the next trial, these parameters revert to their initial values. The default value is 1.

-test_duration_mode

Specifies the duration mode for each transmitted stream. This option determines whether the test duration is measured in seconds or by the number of frames. The default is seconds. Possible values are:

Value             Description

seconds           Each trial lasts for the number of seconds
                   specified by the -test_duration_seconds argument

bursts            Each trial lasts for the number of bursts specified
                   by the -test_duration_bursts argument
-test_duration_bursts

Indicates the transmission length in number of frames, when you specify -test_duration_mode bursts. The default value is 1000.

-test_duration_seconds

Indicates the transmission length in seconds, when you specify -test_duration_mode seconds. The default value is 60.

-test_type

Indicates the type of test to be done. Possible values are:

Value             Description
lr                Line-Rate test.
                   It provide a maximum-rate test for the
                   performance values for throughput, latency, and jitter
                   to verify that a DUT is capable of forwarding packets
                   at line rate under non-congested conditions.
-streamblock_frame_sizes

Specifies whether to use existing streamblock frame size. The default value is false.

-frame_size_mode

Specifies how frame sizes are set and varied through successive test trials. The default value is custom. Possible values are:

Value               Description

custom              Specifies a list of frame sizes specified
                     by the -frame_size argument.

random              Generates random frame sizes within the
                     range between the minimum size
                     (-frame_size_min)  and the maximum size
                     (-frame_size_max).

step                Increases the frame size for each trial from
                     that  of the previous trial. You should use
                     -frame_size_start, -frame_size_end, and
                     -frame_size_step together to generate the
                     frame size list for the test when the
                     -frame_size_mode is set to step.

imix                Specifies a list of frame sizes specified by
                     the -frame_size_imix argument.

Note

The frame size includes the Cyclic Redundancy Check (CRC).

-frame_size

Defines the frame size (in bytes) list for the test when you specify -frame_size_mode custom.

-frame_size_imix

Defines a list of Internet Mix (iMIX) frame size distribution profiles when you specify -frame_size_mode imix. These are preset distribution profiles in Spirent TestCenter:

Name          Description

Default     A simple mix of the three most common frame sizes
            found on the Internet

Spirent     A simple mix of the four most common frame sizes
            found on the Internet

4-Point     The default distribution supplemented by a random
            set of frame sizes

TCPv4       A mix of the most common TCPv4 frame sizes found on
            the Internet

IPSEC       A mix of frame sizes that approximates IPsec traffic

jmix_upstream   A mix of frame sizes that approximate JMIX
                upstream traffic

jmix_downstream  A mix of frame sizes that approximate JMIX
                 downstream traffic

You can use these preset names directly, or use profile names returned by function sth::imix_config when creating custom distribution profiles.

-frame_size_start

Indicates the frame size (in bytes) for the first test trial. The default value is 128. You can specify this argument when -frame_size_mode is set to step.

-frame_size_end

Specifies the maximum frame size (in bytes) for the test. The default value is 256. You can specify this argument when -frame_size_mode is set to step.

-frame_size_step

Specifies the frame size (in bytes) increment. The default value is 128. You can specify this argument when -frame_size_mode is set to step.

-frame_size_min

Indicates the minimum frame size (in bytes) when you use random mode for -frame_size_mode. The default is 128.

-frame_size_max

Indicates the maximum frame size (in bytes) when you use random mode for -frame_size_mode. The default is 256.

-load_type

Specifies the way of varying the load size during the test. Possible values are custom, random, step and fixed. The default value is custom. The types are described below:

custom - The load sizes to use for the test is a list of the load
        sizes that are specified by the -load_list argument.

random - The load sizes to use for the test are the random sizes
         between the minimum size specified by the -load_min
         argument and the maximum size specified by the -load_max
         argument.

step - The load sizes increase by the step value (-load_step) with
       each test iteration, beginning with the start value
       (-load_start) and increasing to the end value (-load_end).

fixed - The load size to use for the test is the fixed size load.
        This fixed type traffic load can be configured when the
        test type is MicroBurst (-test_type as mb).
-load_unit

Specifies the load unit to use. The default value is percent_line_rate. Possible values are:

 Value                  Description

 bits_per_second        Number of bits per second

frames_per_second       Number of frames per second

inter_burst_gap         Interval between two frames

kilobits_per_second     Number of kilobits per second

megabits_per_second     Number of megabits per second

percent_line_rate       Percentage of the line rate
-load_list

Defines the list of load sizes. You can specify this option when -load_type is set to custom.

-load_start

Indicates the load size for the first trial. The default is 10. You can use this argument when you specify -load_type step. You should use -load_start, -load_end, and -load_step together to generate the load value list when you specify -load_type step.

-load_end

Specifies the maximum load value for a trial. The default is 50. You can use this argument when you specify -load_type step. Please refer to -load_type for more information.

-load_step

Indicates the difference between two load sizes. The default is 10. You can use this argument when you specify -load_type step. Please refer to -load_type for more information.

-load_min

Specifies the minimum load value for a trial. You can use this argument when you specify -load_type random. Please refer to -load_type for more information. The default is 10.

-load_max

Specifies the maximum load value for a trial. You can use this argument when you specify -load_type random. Please refer to -load_type for more information. The default is 50.

-load_fixed

Specifies the fixed load value for a trial. You can use this argument when you specify -load_type as fixed and -test_type as mb.

-latency_distribution_list

Specifies a list of latency values (in microseconds)

-burst_type

Specifies the way of varying the burst size during the MicroBurst test. Possible values are custom, random, step and fixed. The default value is custom. The types are described below:

custom - The burst sizes to use for the test is a list of burst
        sizes that are specified by the -burst_list argument.

step - The burst sizes increase by the step value (-burst_step) with
       each test iteration, beginning with the start value
       (-burst_start) and increasing to the end value (-burst_end).

fixed - The burst size to use for the test is the fixed burst size.
        This fixed type burst size can be configured when the
        test type is MicroBurst (-test_type as mb).
-burst_list

Defines the list of burst sizes. You can specify this option when -burst_type is set to custom and -test_type as mb.

-burst_start

Indicates the burst size for the first trial. The default is 1. You can use this argument when you specify -burst_type as step. You should use -burst_start, -burst_end, and -burst_step together to generate the burst value list when you specify -burst_type as step.

-burst_end

Specifies the maximum burst value for a trial. The default is 1. You can use this argument when you specify -burst_type as step and -test_type as mb.

-burst_step

Indicates the difference between two burst sizes. The default is 1. You can use this argument when you specify -burst_type as step and -test_type as mb.

-burst_fixed

Specifies the fixed burst value for a trial. You can use this argument when you specify -burst_type as fixed and -test_type as mb. The default value is 1.

-burst_inter_frame_gap

Specifies the size of the inter-frame gap, in bytes. You can use this argument when you specify -test_type as mb. The default value is 12.

-latency_type

Specifies the latency calculation methods. The default value is LILO. the latency calculation methods. Possible values are:

Value             Description
FILO              First-In Last-Out latency

FIFO              First-In First-Out latency
-start_traffic_delay

Specifies the delay (in seconds) before test traffic is transmitted. This delay occurs after the learning period, when test frames are sent to determine whether the DUT/SUT correctly forwards frames to their destination. Possible values range from 0 to 3600. The default value is 2.

-stagger_start_delay

Specifies the delay, measured in microseconds, between each transmission. Spirent HLTAPI multiplies the value by 64. For example, if you enter 5, the staggered start is 320 microseconds between each port starting traffic. A non-zero value causes the test ports to transmit test traffic in sequence. A zero value causes the test ports to send traffic all at once. Possible values range from 0 to 65. The default is 0.

-delay_after_transmission

Specifies the delay after transmission in seconds. Possible values range from 0 to 3600. The default value is 15.

-enable_learning

Determines whether enables learning mode or not. Possible values are 0 and 1. When it is set to 1, the options related to learning are valid. The default is 1.

-learning_mode

Defines Layer 2 learning mode or Layer 3 learning mode. The default value is l3. Possible values are:

Value              Description
l2                 Layer 2 learning mode

l3                 Layer 3 learning mode
-learning_frequency

Specifies the frequency for sending learning frames. The default value is learn_once. Possible values are:

Value                      Description
learn_once                 Sends learning frames once before
                            the test starts

learn_every_trial          Sends learning frames before each
                            trial begins

learn_every_frame_size     Sends learning frames upon each
                            iteration in frame size

learn_every_iteration      Sends learning frames before each
                            iteration begins
-learning_rate

Specifies the rate, measured in frames per second, at which learning frames are sent to the SUT. You must specify -learning_mode to l2.

-l3_learning_retry_count

Specifies the number of Layer 3 learning retries if transmission, learning verification, or link errors occur. Possible values range from 1-100. The default is 5. You can specify this argument when you specify -learning_mode l3.

-l2_learning_repeat_count

Specifies the number of Layer 2 learning retries if transmission, learning verification, or link errors occur. Possible values range from 1-100. The default is 5. You can specify this argument when you specify -learning_mode l2.

-l2_delay_before_learning

Specifies the delay before L2 learning in seconds. Possible values range from 0-3600. The default is 2. You can specify this argument when you specify -learning_mode l2.

-l3_delay_before_learning

Specifies the delay before L3 learning in seconds. Possible values range from 0-3600. The default is 2. You can specify this argument when you specify -learning_mode l3.

-l2_fixed_frame_size

Specifies the l2 learning frame size. The default value is 64. You can use this argument when you specify -learning_mode l2.

-l2_learning_frame_size_mode

Specifies the mode of learning l2 frame size. The default value is fixed. You can use this argument when you specify -learning_mode l2.

-enable_cyclic_resolution

Enables or disables the Layer 3 cyclic address resolution. Possible values are 0 (disable) and 1 (enable). Spirent TestCenter sends as many Address Resolution Protocol (ARP) /Neighbor Discovery (ND) requests as the number of source IP addresses. The intended use for this option is to seed the DUT’s ARP cache with the source IP and MAC addresses. If this option is disabled, only one ARP/ND request is sent. The default is 1. You can specify this argument when -learning_mode is set to l3.

-enable_traffic_verification

When enabled, verification commands will be added to the test sequence. Possible values are true and false. The default value is false.

-traffic_verification_freq_mode

Specifies when to perform traffic verification during the test. The default value is verify_every_iteration. This option is available when -enable_traffic_verification is set as true. Possible values are:

Value                      Description
verify_every_trial         Verify traffic forwarding at the
                            beginning of every trial

verify_every_frame_size    Verify traffic forwarding after
                            changing the frame size

verify_every_iteration     Verify traffic forwarding at the
                            beginning of every iteration
-traffic_verification_abort_on_fail

Specifies the test behavior when traffic verification fails. Possible values are true and false. When set to true, Spirent HLTAPI stops the test if a fail result is detected on any port or stream. The default value is true. This option is available when -enable_traffic_verification is set as true.

-traffic_verification_tx_frame_count

Specifies the number of frames to send from each port for traffic verification. Possible values range from 0 to 32767. The default value is 100. This option is available when -enable_traffic_verification is set as true.

-traffic_verification_tx_frame_rate

Specifies the traffic rate in frames per second to use for verification. Possible values range from 0 to 14880952. The default value is 100. This option is available when -enable_traffic_verification is set as true.

-display_load_unit

Specifies the unit used in results. The default value is percent_line_rate. Possible values are:

Value                  Description
bits_per_second        Specify results in bps

frames_per_second      Specify results in frames/sec

inter_burst_gap        Specify results in inter-burst gap

kilobits_per_second    Specify results in Kbps

megabits_per_second    Specify results in Mbps

percent_line_rate      Specify results as a percentage

Arguments Unsupported by Save as HLTAPI

None.

Return Values

Depending on the specific language that HLTAPI uses, the function returns a keyed list/dictionary/hash (See Introduction for more information on return value formats) using the following keys (with corresponding data):

handle    Identifies the created test instance.
status    Success (1) or failure (0) of the operation.
log       An error message (if the operation failed).

Description

The sth::test_rfc8239_config function creates, modifies, or deletes an RFC 8239 test that can be a Line-Rate test. Use the -mode argument to specify the action to perform. (See the -mode argument description for information about the actions.)

Once the RFC 8239 test has been configured, a handle is created, which can be used to modify the created test. (See the -mode argument description for more information).

You must specify the -mode (create, modify, or delete) argument.

You can use one of the following methods to create a stream used in the created test:

  • You can enable the -endpoint_creation parameter that indicates you will use new endpoints to create streams for the test. Then you must use the -src_port option and the -dst_port option to specify the source port handle and the destination port handle on which to emulate new streams.
  • You can specify -src_endpoints and -dst_endpoints to create a bound stream for the test.
  • You can provide a list of existing streams by specifying -streamblock_handle for the test.

For more information about the protocol, see RFC 8239.

Examples

#### HLTAPI for Tcl ####

The following example creates a Line-Rate test:

set line_rate_cfg [sth::test_rfc8239_config \
           -mode                                             create\
           -test_type                                        lr \
           -streamblock_handle                               streamblock1 \
           -endpoint_creation                                0 \
           -latency_type                                     FIFO \
           -start_traffic_delay                              3 \
           -stagger_start_delay                              4 \
           -delay_after_transmission                         30 \
           -enable_learning                                  1 \
           -learning_mode                                    l2 \
           -learning_frequency                               learn_every_trial \
           -learning_rate                                    2000 \
           -l2_delay_before_learning                         4 \
           -l2_learning_repeat_count                         8 \
           -l2_fixed_frame_size                              256 \
           -l2_learning_frame_size_mode                      fixed \
           -enable_traffic_verification                      true \
           -traffic_verification_freq_mode                   verify_every_trial \
           -traffic_verification_abort_on_fail               true \
           -traffic_verification_tx_frame_count              200 \
           -traffic_verification_tx_frame_rate               2000 \
           -iteration_count                                  2 \
           -test_duration_mode                               bursts \
           -test_duration_bursts                             1300 \
           -streamblock_frame_sizes                          false \
           -frame_size_mode                                  custom \
           -frame_size                                       "64 512" \
           -load_unit                                        percent_line_rate\
           -load_type                                        custom \
           -load_list                                        "10 30" ]

Sample Output:

{status 1} {handle rfc8239linerateconfig2}

The following example creates a MicroBurst test:

set line_rate_cfg [sth::test_rfc8239_config \
           -mode                                             create\
           -test_type                                        mb \
           -streamblock_handle                               streamblock1 \
           -endpoint_creation                                0 \
           -latency_type                                     FIFO \
           -start_traffic_delay                              3 \
           -stagger_start_delay                              4 \
           -delay_after_transmission                         30 \
           -enable_learning                                  1 \
           -learning_mode                                    l2 \
           -learning_frequency                               learn_every_trial \
           -learning_rate                                    2000 \
           -l2_delay_before_learning                         4 \
           -l2_learning_repeat_count                         8 \
           -l2_fixed_frame_size                              256 \
           -l2_learning_frame_size_mode                      fixed \
           -enable_traffic_verification                      true \
           -traffic_verification_freq_mode                   verify_every_trial \
           -traffic_verification_abort_on_fail               true \
           -traffic_verification_tx_frame_count              200 \
           -traffic_verification_tx_frame_rate               2000 \
           -iteration_count                                  1 \
           -test_duration_mode                               bursts \
           -test_duration_bursts                             1300 \
           -streamblock_frame_sizes                          false \
           -frame_size_mode                                  custom \
           -frame_size                                       "128" \
           -load_unit                                        percent_line_rate\
           -load_type                                        custom \
           -load_list                                        "30" \
           -burst_type                                       step \
           -burst_start                                      20 \
           -burst_end                                        20 \
           -burst_step                                       20 \
           -burst_inter_frame_gap                            16 ]

Sample Output:

{status 1} {handle rfc8239microburstconfig2}

The following example modifies a created test:

sth::test_rfc8239_config -mode modify \
          -handle                            [keylget line_rate_cfg handle] \
          -test_type                         lr \
          -learning_rate                     1200 \
          -l2_delay_before_learning          6 \
          -l2_learning_repeat_count          4 \
          -l2_fixed_frame_size               512 \

Sample Output:

{status 1}

#### HLTAPI for Python ####

The following example creates a Line-Rate test:

rfc_cfg0 = sth.test_rfc8239_config (
         mode                                             = 'create',
         test_type                                        = 'lr',
         streamblock_handle                               = streamblock_ret1['stream_id'],
         endpoint_creation                                = '0',
         latency_type                                     = 'FIFO',
         start_traffic_delay                              = '3',
         stagger_start_delay                              = '4',
         delay_after_transmission                         = '30',
         enable_learning                                  = '1',
         learning_mode                                    = 'l2',
         learning_frequency                               = 'learn_every_trial',
         learning_rate                                    = '2000',
         l2_delay_before_learning                         = '4',
         l2_learning_repeat_count                         = '8',
         l2_fixed_frame_size                              = '256',
         l2_learning_frame_size_mode                      = 'fixed',
         enable_traffic_verification                      = 'true',
         traffic_verification_freq_mode                   = 'verify_every_trial',
         traffic_verification_abort_on_fail               = 'true',
         traffic_verification_tx_frame_count              = '200',
         traffic_verification_tx_frame_rate               = '2000',
         iteration_count                                  = '1',
         test_duration_mode                               = 'bursts',
         test_duration_bursts                             = '1300',
         streamblock_frame_sizes                          = 'false',
         frame_size_mode                                  = 'custom',
         frame_size                                       = "64",
         latency_distribution_list                        = "64",
         load_unit                                        = 'percent_line_rate',
         load_type                                        = 'custom',
         load_list                                        = ['10', '20']);

Sample Output:

{'status': '1', 'handle': 'rfc8239linerateconfig2'}

The following example creates a MicroBurst test:

rfc_cfg0 = sth.test_rfc8239_config (
         mode                                             = 'create',
         test_type                                        = 'mb',
         streamblock_handle                               = 'streamblock1',
         endpoint_creation                                = '0',
         latency_type                                     = 'FIFO',
         start_traffic_delay                              = '3',
         stagger_start_delay                              = '4',
         delay_after_transmission                         = '30',
         enable_learning                                  = '1',
         learning_mode                                    = 'l2',
         learning_frequency                               = 'learn_every_trial',
         learning_rate                                    = '2000',
         l2_delay_before_learning                         = '4',
         l2_learning_repeat_count                         = '8',
         l2_fixed_frame_size                              = '256',
         l2_learning_frame_size_mode                      = 'fixed',
         enable_traffic_verification                      = 'true',
         traffic_verification_freq_mode                   = 'verify_every_trial',
         traffic_verification_abort_on_fail               = 'true',
         traffic_verification_tx_frame_count              = '200',
         traffic_verification_tx_frame_rate               = '2000',
         iteration_count                                  = '1',
         test_duration_mode                               = 'bursts',
         test_duration_bursts                             = '1300',
         streamblock_frame_sizes                          = 'false',
         frame_size_mode                                  = 'custom',
         frame_size                                       = '64',
         load_unit                                        = 'percent_line_rate',
         load_type                                        = 'custom',
         burst_type                                       = 'step',
         burst_start                                      = '20',
         burst_end                                        = '20',
         burst_step                                       = '20',
         burst_inter_frame_gap                            = '16',
         load_list                                        = ['30']);

Sample Output:

{'status': '1', 'handle': 'rfc8239microburstconfig2'}

End of Procedure Header

sth::test_rfc8239_control

Purpose

Controls the RFC 8239 tests.

Synopsis

Note

M indicates that the argument is Mandatory .

sth::test_rfc8239_control
    [-action {run | insert_breakpoint | remove_breakpoint | stop}  M]
    [-wait {0|1}]
    [-breakpoint {trial | framesize | load}]
    [-cleanup {0|1}]

Arguments

-action

Specifies the action to perform for the test. Possible values are run and stop. The modes are described below:

run                - Starts the test. You can start one test in each type.
insert_breakpoint  - Inserts a pause on selected commands. The Command
                     Sequencer pauses on commands that contain a breakpoint
                     before running them.
remove_breakpoint  - Removes a pause from selected commands.
stop               - Stops the test.
-wait

Determines whether this command will return only when the test is completed. Possible values are 0 and 1. The default is 1. When it is set to 1, the command will return only when the test is completed.

-breakpoint

Specifies the command name to pause the sequencer test. Possible values are:

trial      - Pauses the test at each trial iteration.
framesize  - Pauses the test at each frame size iteration.
load       - Pauses the test at each load size iteration.
-cleanup

Determines whether the current test instance should be deleted after the test is completed. Possible values are 0 and 1. The default value is 0. When it is set to 1, the current test instance will be deleted after the test is completed.

Return Values

Depending on the specific language that HLTAPI uses, the function returns a keyed list/dictionary/hash (See Introduction for more information on return value formats) using the following keys (with corresponding data):

status $SUCCESS or $FAILURE log Error message if command returns {status 0}

Description

The sth::test_rfc8239_control function controls the starting and stopping of the test.

Examples

#### HLTAPI for Tcl ####

The following example starts all current configured tests at the same time and does not do the cleanup action when the tests stop:

set ret [sth::test_rfc8239_control -action run -wait 1 -cleanup 0]

Sample output for the example shown above:

{status 1}

#### HLTAPI for Python ####

The following example starts all current configured tests:

ctrl_ret1 = sth.test_rfc8239_control (
              action              = 'run',
              cleanup              = '0',
              wait                = '1');

Sample Output:

{'status': '1'}

End of Procedure Header

sth::test_rfc8239_info

Purpose

Retrieves statistics for the configured RFC8239 test.

Synopsis

Note

M indicates that the argument is Mandatory .

sth::test_rfc8239_info
    [-test_type {lr|mb}  M]
    [-result_type {lr_frame_size|lr_load_size|lr_basic|mb_frame_size|mb_load_size|mb_burst_size|mb_stream_block}]
    [-clear_db {0|1}]

Arguments

-test_type

Specifies the type of the test, whose information will be returned. This argument is Mandatory . Possible values are lr and mb.

-result_type

Specifies the type of result properties to be returned. When the test_type is lr, possible values are lr_frame_size lr_load_size, and lr_basic and when test_type is mb, possible values are mb_frame_size, mb_load_size, mb_burst_size and mb_stream_block.

-clear_db

Specifies to stop and delete the TestCenter IQ database at the end of the test. Possible values are 0 and 1. The default is 1. If the value is set to 1, test will stop and delete the db. If the value is set to 0, test will not stop and delete the db.

Return Values

Depending on the specific language that HLTAPI uses, the function returns a keyed list/dictionary/hash (See Introduction for more information on return value formats) using the following keys (with corresponding data):

status             SUCCESS or $FAILURE log Error message if command returns {status 0}

statistics list    Specifies the list of RFC 8239 statistics

The following keys are returned when you specify -result_type lr_load_size::

  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.test_snapshot_name
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.min_jitter
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value><load value>.test_frame_size
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.test_load_size
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.test_trial_number
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.tx_frame_count
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.avg_latency
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.max_latency
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.max_jitter
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.rx_frame_count
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.avg_jitter
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.min_latency

The following keys are returned when you specify -result_type as lr_frame_size::

  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.test_snapshot_name
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.avg_latency
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.test_trial_number
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.offered_fps_load
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.min_jitter
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.test_load_size
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.max_jitter
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.tx_frame_count
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.test_frame_size
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.offered_bps_load
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.rx_frame_count
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.max_latency
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.avg_jitter
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.min_latency
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.offered_pct_load
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.tx_frame_rate

The following keys are returned when you specify -result_type as lr_basic::

  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.test_snapshot_name
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.tx_port_basic_stats_total_frame_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.tx_port_basic_stats_total_octet_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.tx_port_basic_stats_generator_sig_frame_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.tx_port_basic_stats_total_bit_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.rx_port_basic_stats_total_bit_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.rx_port_basic_stats_total_frame_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.rx_port_basic_stats_sig_frame_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.rx_port_basic_stats_total_octet_count

The following keys are returned when you specify -result_type mb_frame_size::

  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_snapshot_name
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_trial_number
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value><load value>.<burst size value>.test_frame_size
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_load_size
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_burst_size
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_ingress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_egress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_rate
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.rx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.frame_loss
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.percent_loss

The following keys are returned when you specify -result_type as mb_load_size::

  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_snapshot_name
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_trial_number
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_frame_size
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_load_size
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_burst_size
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_ingress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_egress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_rate
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.rx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.frame_loss
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.percent_loss

The following keys are returned when you specify -result_type as mb_burst_size::

  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_snapshot_name
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_trial_number
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_frame_size
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_load_size
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_burst_size
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_ingress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_egress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_rate
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.rx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.frame_loss
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.percent_loss

The following keys are returned when you specify -result_type as mb_stream_block::

  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_snapshot_name
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_trial_number
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_frame_size
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_load_size
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_burst_size
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_ingress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_egress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_rate
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.rx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.frame_loss
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.percent_loss

Description

The sth::test_rfc8239_info function provides information about the configured tests.

This function returns the requested data and a status value (1 for success). If there is an error, the function returns the status value (0). Function return values are formatted as a keyed list (supported by the Tcl extension software - TclX). Use the TclX function keylget to retrieve data from the keyed list. (See Return Values for a description of each key.)

Examples

#### HLTAPI for Tcl ####

To return Line-Rate per load results:

set ret [sth::test_rfc8239_info -test_type lr -result_type lr_load_size]

Sample Output:

{status 1} {rfc8239 {{linerate {{LineRate_Per_LoadSize_Result {{T1 {{512 {{30 {
 {test_snapshot_name T1-FrameSize:512-Load:30} {test_trial_number 1} {test_frame_size 512}
 {test_load_size 30} {tx_frame_count 1300} {rx_frame_count 1300} {avg_latency -26.937}
 {min_latency -36.52} {max_latency 48.69} {avg_jitter null} {min_jitter null}
 {max_jitter null}}}}}}}}}}}}}

To return Line-Rate per frame size results:

set ret [sth::test_rfc8239_info -test_type lr -result_type lr_frame_size]

Sample Output:

{status 1} {rfc8239 {{linerate {{LineRate_Per_FrameSize_Result {{T1 {{512 {{30 {
 {test_snapshot_name T1-FrameSize:512-Load:30} {test_trial_number 1} {test_frame_size 512}
 {test_load_size 30} {tx_frame_count 1300} {rx_frame_count 1300} {tx_frame_rate 70488}
 {offered_pct_load 30} {offered_fps_load 70488} {offered_bps_load 299996928}
 {avg_latency -35.615} {min_latency -44.27} {max_latency 53.57} {avg_jitter null}
 {min_jitter null} {max_jitter null}}}}}}}}}}}}}

To return Line-Rate basic results:

set ret [sth::test_rfc8239_info -test_type lr -result_type lr_basic]

Sample Output:

{status 1} {rfc8239 {{linerate {{LineRate_Basic_Summary_Result {{T1 {{512 {{30
{{test_snapshot_name T1-FrameSize:512-Load:30} {test_trial_number 1} {test_frame_size 512}
{test_load_size 30} {tx_frame_count 1300} {rx_frame_count 1300} {avg_latency -21.63}
{min_latency -30.44} {max_latency 167.82} {avg_jitter null} {min_jitter null}
{max_jitter null}}}}}}}}}}}}}

To return MicroBurst per frame size results:

set ret [sth::test_rfc8239_info -test_type mb -result_type mb_frame_size]

Sample Output:

{status 1} {rfc8239 {{microburst {{MicroBurst_Per_FrameSize_Result {{T1 {{128 {{30 {{20 {
{test_snapshot_name T1-NumTxPorts:1-NumRxPorts:1-FrameSize:128-Load:30-Burst:20-Frames} {
test_trial_number 1} {test_frame_size 128} {test_load_size 30} {test_burst_size 20}
{test_num_ingress_ports 1} {test_num_egress_ports 1} {tx_frame_rate 253378} {tx_frame_count
26000} {rx_frame_count 26000} {frame_loss 0} {percent_loss 0}}}}}}}}}}}}}}}

To return MicroBurst per load size results:

set ret [sth::test_rfc8239_info -test_type mb -result_type mb_load_size]

Sample Output:

{status 1} {rfc8239 {{microburst {{MicroBurst_Per_LoadSize_Result {{T1 {{128 {{30 {{20 {{test_snapshot_name T1-NumTxPorts:1-NumRxPorts:1-FrameSize:128-Load:30-Burst:20-Frames} {test_trial_number 1} {test_frame_size 128} {test_load_size 30} {test_burst_size 20} {test_num_ingress_ports 1} {test_num_egress_ports 1} {tx_frame_rate 253378} {tx_frame_count 26000} {rx_frame_count 26000} {frame_loss 0} {percent_loss 0}}}}}}}}}}}}}}}

To return MicroBurst per burst size results:

set ret [sth::test_rfc8239_info -test_type mb -result_type mb_burst_size]

Sample Output:

{status 1} {rfc8239 {{microburst {{MicroBurst_Per_BurstSize_Result {{T1 {{128 {{30 {{20 {{test_snapshot_name T1-NumTxPorts:1-NumRxPorts:1-FrameSize:128-Load:30-Burst:20-Frames} {test_trial_number 1} {test_frame_size 128} {test_load_size 30} {test_burst_size 20} {test_num_ingress_ports 1} {test_num_egress_ports 1} {tx_frame_rate 253378} {tx_frame_count 26000} {rx_frame_count 26000} {frame_loss 0} {percent_loss 0}}}}}}}}}}} }}}}

To return MicroBurst per streamblock results:

set ret [sth::test_rfc8239_info -test_type mb -result_type mb_stream_block]

Sample Output:

{status 1} {rfc8239 {{microburst {{MicroBurst_Per_StreamBlock_Result {{T1 {{128 {{30 {{20 {{test_snapshot_name T1-NumTxPorts:1-NumRxPorts:1-FrameSize:128-Load:30-Burst:20-Frames} {test_trial_number 1} {test_frame_size 128} {test_load_size 30} {test_burst_size 20} {test_num_ingress_ports 1} {test_num_egress_ports 1} {tx_frame_rate 253378} {tx_frame_count 26000} {rx_frame_count 26000} {frame_loss 0} {percent_loss 0}}}}}}}}}}}}}}}

#### HLTAPI for Python ####

To return Line-Rate per load results:

ret  = sth.test_rfc8239_info (
       test_type                                 = 'lr',
       result_type                               = 'lr_load_size' );

Sample Output:

{'rfc8239': {'linerate': {'LineRate_Per_LoadSize_Result': {'T1': {'frame_size':
 {'64': {'load': {'10': {'min_jitter': 'null', 'test_frame_size': '64',
 'test_load_size': '10', 'test_snapshot_name': 'T1-FrameSize:64-Load:10',
 'test_trial_number': '1', 'tx_frame_count': '1300', 'avg_latency': '-38.542',
 'max_latency': '59.53', 'max_jitter': 'null', 'rx_frame_count': '1300',
 'avg_jitter': 'null', 'test_snapshot_name_pylist': ['T1-FrameSize:64-Load:10'],
 'min_latency': '-45.23'}, '20': {'min_jitter': 'null', 'test_frame_size': '64',
 'test_load_size': '20', 'test_snapshot_name': 'T1-FrameSize:64-Load:20',
 'test_trial_number': '1', 'tx_frame_count': '1300', 'avg_latency': '-38.997',
 'max_latency': '24.18', 'max_jitter': 'null', 'rx_frame_count': '1300',
 'avg_jitter': 'null', 'test_snapshot_name_pylist': ['T1-FrameSize:64-Load:20'],
 'min_latency': '-44.58'}}}}}}}}, 'status': '1'}

To return Line-Rate per frame size results:

ret  = sth.test_rfc8239_info (
       test_type                                 = 'lr',
       result_type                               = 'lr_frame_size' );

Sample Output:

{'rfc8239': {'linerate': {'LineRate_Per_FrameSize_Result': {'T1': {'frame_size':
 {'64': {'load': {'20': {'avg_latency': '-2.167', 'test_trial_number': '1',
 'offered_fps_load': '0', 'min_jitter': 'null', 'test_load_size': '20',
 'test_snapshot_name': 'T1-FrameSize:64-Load:20', 'test_snapshot_name_pylist':
 ['T1-FrameSize:64-Load:20'], 'max_jitter': 'null', 'tx_frame_count': '1300',
 'test_frame_size': '64', 'offered_bps_load': '0', 'rx_frame_count': '1300',
 'max_latency': '84.82', 'avg_jitter': 'null', 'min_latency': '-9.42',
 'offered_pct_load': '0', 'tx_frame_rate': 'null'}}}}}}}}, 'status': '1'}

To return Line-Rate basic results:

ret  = sth.test_rfc8239_info (
       test_type                                 = 'lr',
       result_type                               = 'lr_basic' );

Sample Output:

{'rfc8239': {'linerate': {'LineRate_Basic_Summary_Result': {'T1': {'frame_size':
 {'64': {'load': {'10': {'tx_port_basic_stats_total_frame_count': '1300',
 'test_snapshot_name': 'T1-FrameSize:64-Load:10', 'tx_port_basic_stats_total_octet_count':
 '83200', 'tx_port_basic_stats_generator_sig_frame_count': '1300',
 'tx_port_basic_stats_total_bit_count': '665600', 'rx_port_basic_stats_total_bit_count':
 '665600', 'rx_port_basic_stats_total_frame_count': '1300', 'test_snapshot_name_pylist':
 ['T1-FrameSize:64-Load:10'], 'rx_port_basic_stats_sig_frame_count': '1300',
 'rx_port_basic_stats_total_octet_count': '83200'}, '20': {'tx_port_basic_stats_total_frame_count':
 '1300', 'test_snapshot_name': 'T1-FrameSize:64-Load:20', 'tx_port_basic_stats_total_octet_count':
 '83200', 'tx_port_basic_stats_generator_sig_frame_count': '1300',
 'tx_port_basic_stats_total_bit_count': '665600', 'rx_port_basic_stats_total_bit_count': '665600',
 'rx_port_basic_stats_total_frame_count': '1300', 'test_snapshot_name_pylist': ['T1-FrameSize:64-Load:20'],
 'rx_port_basic_stats_sig_frame_count': '1300', 'rx_port_basic_stats_total_octet_count': '83200'}}}}}}}},
 'status': '1'}

To return MicroBurst per frame size results:

ret  = sth.test_rfc8239_info (
       test_type                                 = 'mb',
       result_type                               = 'mb_frame_size' );

Sample Output:

{{'status': '1', 'rfc8239': {'microburst': {'MicroBurst_Per_FrameSize_Result':
{'T1': {'64': {'30': {'20': {'percent_loss': '0', 'frame_loss': '0',
'test_burst_size': '20', 'tx_frame_count': '26000', 'test_snapshot_name_pylist':
['T1-NumTxPorts:1-NumRxPorts:1-FrameSize:64-Load:30-Burst:20-Frames'],
'test_num_ingress_ports': '1', 'test_num_egress_ports': '1', 'test_trial_number':
'1', 'test_load_size': '30', 'test_frame_size': '64', 'rx_frame_count': '26000',
'test_snapshot_name': 'T1-NumTxPorts:1-NumRxPorts:1-FrameSize:64-Load:30-Burst:20-Frames',
'tx_frame_rate': '446428'}}}}}}}}

To return MicroBurst per load size results:

ret  = sth.test_rfc8239_info (
       test_type                                 = 'mb',
       result_type                               = 'mb_load_size' );

Sample Output:

{'status': '1', 'rfc8239': {'microburst': {'MicroBurst_Per_LoadSize_Result':
{'T1': {'64': {'30': {'20': {'percent_loss': '0', 'frame_loss': '0', 'test_burst_size':
'20', 'tx_frame_count': '26000', 'test_snapshot_name_pylist':
['T1-NumTxPorts:1-NumRxPorts:1-FrameSize:64-Load:30-Burst:20-Frames'],
'test_num_ingress_ports': '1', 'test_num_egress_ports': '1', 'test_trial_number': '1',
'test_load_size': '30', 'test_frame_size': '64', 'rx_frame_count': '26000', 'test_snapshot_name': 'T1-NumTxPorts:1-NumRxPorts:1-FrameSize:64-Load:30-Burst:20-Frames', 'tx_frame_rate': '446428'}}}}}}}}

To return MicroBurst per burst size results:

ret  = sth.test_rfc8239_info (
       test_type                                 = 'mb',
       result_type                               = 'mb_burst_size' );

Sample Output:

{'status': '1', 'rfc8239': {'microburst': {'MicroBurst_Per_BurstSize_Result':
{'T1': {'64': {'30': {'20': {'percent_loss': '0', 'frame_loss': '0',
'test_burst_size': '20', 'tx_frame_count': '26000', 'test_snapshot_name_pylist':
['T1-NumTxPorts:1-NumRxPorts:1-FrameSize:64-Load:30-Burst:20-Frames'],
'test_num_ingress_ports': '1', 'test_num_egress_ports': '1', 'test_trial_number': '1',
'test_load_size': '30', 'test_frame_size': '64', 'rx_frame_count': '26000', 'test_snapshot_name': 'T1-NumTxPorts:1-NumRxPorts:1-FrameSize:64-Load:30-Burst:20-Frames', 'tx_frame_rate': '446428'}}}}}}}}

To return MicroBurst per streamblock results:

ret  = sth.test_rfc8239_info (
       test_type                                 = 'mb',
       result_type                               = 'mb_stream_block' );

Sample Output:

{'status': '1', 'rfc8239': {'microburst': {'MicroBurst_Per_StreamBlock_Result': {'T1':
{'64': {'30': {'20': {'percent_loss': '0', 'frame_loss': '0', 'test_burst_size': '20',
'tx_frame_count': '26000', 'test_snapshot_name_pylist':
['T1-NumTxPorts:1-NumRxPorts:1-FrameSize:64-Load:30-Burst:20-Frames'], 'test_num_ingress_ports':
'1', 'test_num_egress_ports': '1', 'test_trial_number': '1', 'test_load_size': '30',
'test_frame_size': '64', 'rx_frame_count': '26000', 'test_snapshot_name':
'T1-NumTxPorts:1-NumRxPorts:1-FrameSize:64-Load:30-Burst:20-Frames', 'tx_frame_rate': '446428'}}}}}}}}

End of Procedure Header