TREX STL client API v2.49 - clear stats problem

[hakl...@gmail.com]

Hi,

I am using the TREX stateless python API. I have a script that has been working fine for some time at least up to v2.39. Now when upgrading to v2.49 it seams statistics clearing has changed. Before I think it was enough only reseting ports (c.reset(ports = [first_port, second_port])) before each new traffic iteration. Now I am also adding clear_stats and it works better. But problem is that latency error stats, e.g. the latency drops or reordering counters does not seem to get cleared by this. What am I missing in order to also clear those counters properly between runs?


Now looks like:
c.clear_stats()
# start and wait for completion
c.start(ports = [first_port,second_port],force=True)

In the below, when getting the counters after test iteration, I think clear_stats at least cleared the latency counters properly but not the err_cntrs.

flow_stats = flow_stats_lat.get(pgids[i])
dup = flow_stats['err_cntrs'].get('dup')
ooo = flow_stats['err_cntrs'].get('out_of_order')
shigh = flow_stats['err_cntrs'].get('seq_too_high')
slow = flow_stats['err_cntrs'].get('seq_too_low')
drop = flow_stats['err_cntrs'].get('dropped')
maxlat = flow_stats['latency'].get('total_max')
minlat = flow_stats['latency'].get('total_min')
avglat = flow_stats['latency'].get('average')
jitter = flow_stats['latency'].get('jitter')


What actually happens is that if I have one iteration with some errors. They will show up in next actually error free iterartion as minus numbers. Like my printout example below, this is the problem:

Latency streams (1000 PPS):

Latency_stream Duplicats OutOfOrder Seq_high Seq_low Drop Lat_max(us) Lat_min(us) Lat_avg(us) Jitter(us)

Stream1010 0 0 2851 0 3007 6242 50 5924.22 28

Stream10010 0 0 2973 0 3134 6294 100 5955.70 83



Next iteration after clear_stats():

Latency_stream Duplicats OutOfOrder Seq_high Seq_low Drop Lat_max(us) Lat_min(us) Lat_avg(us) Jitter(us)

Stream1010 0 0 -2851 0 -3007 99 30 55.91 12

Stream10010 0 0 -2973 0 -3134 178 60 142.33 30


BR/Håkan

[Yaroslav Brustinov]

Hi,

Is the error consistent?

Could you provide minimal reproducing script?

Thanks,

Yaroslav.

--
You received this message because you are subscribed to the Google Groups "TRex Traffic Generator" group.
To unsubscribe from this group and stop receiving emails from it, send an email to trex-tgn+u...@googlegroups.com.
To post to this group, send email to trex...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/trex-tgn/bce0b2ff-837e-45e9-9fa3-3c509a974c1c%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[hakl...@gmail.com]

Hi,
below are some example parts of the code. Traffic running for some time then calling print function, then again running traffic some time followed by printing results. After a run with drop and/or sequenze error the next run always have the error countes from earlier run in negative (-) (latency conters are creared just fine), next run again after this is OK for both error and latency counters. And problem is consistent. Full script in end of mail.



def print_results():
pgids = c.get_active_pgids()['latency']
flow_stats_lat = c.get_pgid_stats()['latency']
for i in range(len(pgids)):

flow_stats = flow_stats_lat.get(pgids[i])
dup = flow_stats['err_cntrs'].get('dup')
ooo = flow_stats['err_cntrs'].get('out_of_order')
shigh = flow_stats['err_cntrs'].get('seq_too_high')
slow = flow_stats['err_cntrs'].get('seq_too_low')
drop = flow_stats['err_cntrs'].get('dropped')
maxlat = flow_stats['latency'].get('total_max')
minlat = flow_stats['latency'].get('total_min')
avglat = flow_stats['latency'].get('average')
jitter = flow_stats['latency'].get('jitter')

print ("Stream%-8s %-14s %-14s %-14s %-14s %-14s %-14s %-14s %-15.2f %-14s\n" % (pgids[i],dup,ooo,shigh,slow,drop,maxlat,minlat,avglat,jitter))



# connect to server
c.connect()

# prepare our ports - TX/RX
c.reset(ports = [first_port, second_port])

c.set_service_mode(ports = [first_port, second_port], enabled = True)
# configure port 0, 1 to Layer 3 mode
c.set_l3_mode(port = first_port, src_ipv4 = ip_port_0, dst_ipv4 = ip_gw_port_0)
c.set_l3_mode(port = second_port, src_ipv4 = ip_port_1, dst_ipv4 = ip_gw_port_1)
# ARP resolve ports 0, 1
c.resolve(ports = [first_port, second_port])
c.set_service_mode(ports = [first_port, second_port], enabled = False)


def run_traffic(first_port, second_port, pps_lat_flows_loc, pkt_size_loc, duration_loc):

.
.
.
.
.
# Latency Flows
s1 = STLStream(name = 'stream1010',
packet = pkt1,
flow_stats = STLFlowLatencyStats(pg_id = 1010),
mode = STLTXCont( pps = 1000))

s101 = STLStream(name = 'stream10010',
packet = pkt101,
flow_stats = STLFlowLatencyStats(pg_id = 10010),
mode = STLTXCont( pps = 1000))

# Fat Flows
s1lat = STLStream(name = 'stream1011',
packet = pkt1_flows,
flow_stats = STLFlowStats(pg_id = 1011),
mode = STLTXCont( pps = pps_lat_flows))

s101lat = STLStream(name = 'stream10011',
packet = pkt101_flows,
flow_stats = STLFlowStats(pg_id = 10011),
mode = STLTXCont( pps = pps_lat_flows))


# connect to server
c.connect()

# prepare our ports - TX/RX
c.reset(ports = [first_port, second_port])

c.set_service_mode(ports = [first_port, second_port], enabled = True)
# configure port 0, 1 to Layer 3 mode
c.set_l3_mode(port = first_port, src_ipv4 = ip_port_0, dst_ipv4 = ip_gw_port_0)
c.set_l3_mode(port = second_port, src_ipv4 = ip_port_1, dst_ipv4 = ip_gw_port_1)
# ARP resolve ports 0, 1
c.resolve(ports = [first_port, second_port])
c.set_service_mode(ports = [first_port, second_port], enabled = False)


# add the stream to the TX port
c.add_streams([s1,s1lat], ports = [first_port])
c.add_streams([s101,s101lat], ports = [second_port])

c.clear_stats()
# start and wait for completion
c.start(ports = [first_port,second_port],force=True)

timestamp = time.time()
print ("################# %i second test iteration started for frame size %i @ PPS %i ###################################" % (duration,pkt_size,pps_lat_flows))
print ("Traffic started!")
time.sleep(duration)
c.stop(ports = [first_port,second_port])
c.wait_on_traffic(ports = [first_port,second_port])
time.sleep(1)
print_results()

except STLError as e:
passed = False
print(e)

finally:
c.disconnect()




[root@trex-1-vm-nfvi-1190 stl]# cat nfvi_1118_1000_flows.py
#### Script created by xx xx
import stl_path
#from trex_stl_lib.api import *
from trex.stl.api import *
from trex.common.services.trex_service_IPv6ND import ServiceIPv6ND
# Import other python libraries used for presenting results
import json
import time
import datetime
import pprint

# Initiate variable duration. Used to keep track of for how long traffic has been sent.
duration = 0
# flow_stats_array = [ 1011, 10011 ]
#########################Start of variables to edit!##################################################################
#
#
# Create Stateless Client (replace with wanted user name and TREX server IP address)
c = STLClient(username = "nfvi-throughput",server ="127.0.0.1")
port_0 = 0
port_1 = 1
ip_port_0="172.16.10.10"
ip_gw_port_0="172.16.10.1"
ip_port_1="172.16.11.10"
ip_gw_port_1="172.16.11.1"
max_bw_per_flow = 5 #### Gigabit
size_array = [ 64, 560, 1500 ]
ppm_limit = 10.0
flows=1000 #Set to even number form 1000 up to 100000. For case not using multiple flows set flows=1.
init_dur=20
final_dur=900
init_pps=100000 # Start iteration value for all frame sizes, set in steps of 100000 PPS

#
#########################End of variables to edit!####################################################################
udp_flows=int(9999+flows/2)
cache_flow=int(flows/2)
max_pps = {}
failed_pps = {}


# Function for printing results to screen and file
def print_results():
# global port_0_tx_stats
# global port_0_rx_stats
# global port_1_tx_stats
# global port_1_rx_stats
global flow1_PPM_loss
global flow2_PPM_loss
global flow1_actual_pps
global flow2_actual_pps
frame_size = pkt_size
float_frame_size = float(frame_size)
bw_per_flow = (float_frame_size+20)*8*pps_lat_flows/1000000
port_0_tx_stats = c.get_xstats(port_0)['tx_good_packets']
port_0_rx_stats = c.get_xstats(port_0)['rx_good_packets']
port_1_tx_stats = c.get_xstats(port_1)['tx_good_packets']
port_1_rx_stats = c.get_xstats(port_1)['rx_good_packets']

print ("Downstream (total packets):\nPort0 good TX packets:%s\nPort1 good RX packets:%s\n\nUpstream (total packets):\nPort1 good TX packets:%s\nPort0 good RX packets:%s\n" % (port_0_tx_stats, port_1_rx_stats, port_1_tx_stats, port_0_rx_stats))
pgids = c.get_active_pgids()['latency']
print ("Currently used pgids: {0}".format(pgids))
stats = c.get_pgid_stats()
flow_stats_lat = c.get_pgid_stats()['latency']
print ("Total test duration is %.1f seconds!" % (duration))
print ("Packets Per Second sent per test flow @ frame size %i was: %s" % (frame_size, pps_lat_flows))
print ("Bandwidth per flow (Megabit/sec): %.3f" % (bw_per_flow))

print ("Bulk streams:\n")
print ("Stream PPS sent TX_packages RX_packages Dropped\n")
for i in range(len(flow_stats_array)):
flow_stats = c.get_stats()['flow_stats'].get(flow_stats_array[i])
if flow_stats_array[i] < 10000:
tx_pkts = flow_stats['tx_pkts'].get(port_0)
rx_pkts = flow_stats['rx_pkts'].get(port_1)
drop = tx_pkts - rx_pkts
flow1_PPM_loss = drop/(tx_pkts*1.0)
pps = tx_pkts/duration
flow1_actual_pps = pps
print ("Stream%-8s %-14.1f %-14s %-14s %s\n" % (flow_stats_array[i],pps,tx_pkts,rx_pkts,drop))
else:
tx_pkts = flow_stats['tx_pkts'].get(port_1)
rx_pkts = flow_stats['rx_pkts'].get(port_0)
drop = tx_pkts - rx_pkts
flow2_PPM_loss = drop/(tx_pkts*1.0)
pps = tx_pkts/duration
flow2_actual_pps = pps
print ("Stream%-8s %-14.1f %-14s %-14s %s\n" % (flow_stats_array[i],pps,tx_pkts,rx_pkts,drop))

print ("\n")
print ("Latency streams (1000 PPS):\n")

print ("Latency_stream Duplicats OutOfOrder Seq_high Seq_low Drop Lat_max(us) Lat_min(us) Lat_avg(us) Jitter(us)\n")

for i in range(len(pgids)):

flow_stats = flow_stats_lat.get(pgids[i])
dup = flow_stats['err_cntrs'].get('dup')
ooo = flow_stats['err_cntrs'].get('out_of_order')
shigh = flow_stats['err_cntrs'].get('seq_too_high')
slow = flow_stats['err_cntrs'].get('seq_too_low')
drop = flow_stats['err_cntrs'].get('dropped')
maxlat = flow_stats['latency'].get('total_max')
minlat = flow_stats['latency'].get('total_min')
avglat = flow_stats['latency'].get('average')
jitter = flow_stats['latency'].get('jitter')

print ("Stream%-8s %-14s %-14s %-14s %-14s %-14s %-14s %-14s %-15.2f %-14s\n" % (pgids[i],dup,ooo,shigh,slow,drop,maxlat,minlat,avglat,jitter))

# Function for setting up traffic
def setup_traffic (first_port, second_port, pps_lat_flows_loc, pkt_size_loc, duration_loc):
global passed
global duration
global pkt_size
global pps_lat_flows
global flow_stats_array
global udp_flows
global flows
flow_stats_array = [ 1011, 10011 ]
duration = duration_loc
pkt_size = pkt_size_loc
pps_lat_flows = pps_lat_flows_loc
passed = True

base_pkt = Ether()/IP(src="16.0.0.1",dst="48.0.0.1")/UDP(dport=12,sport=1001,chksum=0x0000)
pad = max(0, pkt_size - len(base_pkt)) * 'x'

try:
### Field engine flows below used to generate UDP flows and to measure latency.
### If flow variable set to 1 this means multiple flows should not be used.
if flows != 1:
pkt1_vm = STLScVmRaw( [ STLVmFlowVar ( "src_port",
min_value=10000,
max_value=udp_flows,
size=2,
step=1,
op="inc"),
STLVmWrFlowVar (fv_name="src_port",
pkt_offset= 36 ), # write port to packet UDP.sport
STLVmFixIpv4(offset = "IP") # fix checksum
],
# split_by_field = "src_port",
cache_size = cache_flow # cache the packets, much better performance
)

pkt101_vm = STLScVmRaw( [ STLVmFlowVar ( "dst_port",
min_value=10000,
max_value=udp_flows,
size=2,
step=1,
op="inc"),
STLVmWrFlowVar (fv_name="dst_port",
pkt_offset= 36 ), # write port to packet UDP.dport
STLVmFixIpv4(offset = "IP") # fix checksum
],
# split_by_field = "dst_port",
cache_size = cache_flow # cache the packets, much better performance
)
pkt1_flows = STLPktBuilder(pkt = Ether()/IP(src=ip_port_0,dst=ip_port_1)/UDP(dport=12,sport=10000,chksum=0x0000)/pad,vm=pkt1_vm)
pkt101_flows = STLPktBuilder(pkt = Ether()/IP(src=ip_port_1,dst=ip_port_0)/UDP(dport=10000,sport=12,chksum=0x0000)/pad,vm=pkt101_vm)
else:
pkt1_flows = STLPktBuilder(pkt = Ether()/IP(src=ip_port_0,dst=ip_port_1)/UDP(dport=12,sport=10000,chksum=0x0000)/pad)
pkt101_flows = STLPktBuilder(pkt = Ether()/IP(src=ip_port_1,dst=ip_port_0)/UDP(dport=10000,sport=12,chksum=0x0000)/pad)


pkt1 = STLPktBuilder(pkt = Ether()/IP(src=ip_port_0,dst=ip_port_1)/UDP(dport=12,sport=10000,chksum=0x0000)/pad)

pkt101 = STLPktBuilder(pkt = Ether()/IP(src=ip_port_1,dst=ip_port_0)/UDP(dport=10000,sport=12,chksum=0x0000)/pad)

# Latency Flows
s1 = STLStream(name = 'stream1010',
packet = pkt1,
flow_stats = STLFlowLatencyStats(pg_id = 1010),
mode = STLTXCont( pps = 1000))

s101 = STLStream(name = 'stream10010',
packet = pkt101,
flow_stats = STLFlowLatencyStats(pg_id = 10010),
mode = STLTXCont( pps = 1000))
# Fat Flows
s1lat = STLStream(name = 'stream1011',
packet = pkt1_flows,
flow_stats = STLFlowStats(pg_id = 1011),
mode = STLTXCont( pps = pps_lat_flows))

s101lat = STLStream(name = 'stream10011',
packet = pkt101_flows,
flow_stats = STLFlowStats(pg_id = 10011),
mode = STLTXCont( pps = pps_lat_flows))


# connect to server
c.connect()

# prepare our ports - TX/RX
c.reset(ports = [first_port, second_port])

c.set_service_mode(ports = [first_port, second_port], enabled = True)
# configure port 0, 1 to Layer 3 mode
c.set_l3_mode(port = first_port, src_ipv4 = ip_port_0, dst_ipv4 = ip_gw_port_0)
c.set_l3_mode(port = second_port, src_ipv4 = ip_port_1, dst_ipv4 = ip_gw_port_1)
# ARP resolve ports 0, 1
c.resolve(ports = [first_port, second_port])
c.set_service_mode(ports = [first_port, second_port], enabled = False)


# add the stream to the TX port
c.add_streams([s1,s1lat], ports = [first_port])
c.add_streams([s101,s101lat], ports = [second_port])

c.clear_stats()
# start and wait for completion
c.start(ports = [first_port,second_port],force=True)

timestamp = time.time()
print ("################# %i second test iteration started for frame size %i @ PPS %i ###################################" % (duration,pkt_size,pps_lat_flows))
print ("Traffic started!")
time.sleep(duration)
c.stop(ports = [first_port,second_port])
c.wait_on_traffic(ports = [first_port,second_port])
time.sleep(1)
print_results()

except STLError as e:
passed = False
print(e)

finally:
c.disconnect()

if passed:
print("\nTest has passed :-)\n")
else:
print("\nTest has failed :-(\n")


def search_func(ppm_limit, size_array, init_duration = 30, final_duration = 900):

global max_pps
global failed_pps
global flow1_PPM_loss
global flow2_PPM_loss
global flow1_actual_pps
global flow2_actual_pps
pps_limit = {}
ppm_final_run_flow1 = {}
ppm_final_run_flow2 = {}
for i in size_array:
pps_limit [ i ] = int(((max_bw_per_flow*1000000000/((20+i)*8))//100000)*100000)

### First Run 60 seconds traffic to ensure any learning is done before real test starts
### 60 seconds is enough to establish more than 100000 UDP sessions in connection tracker (1000 per port and second)
### An estabilshed connection tracker UDP flow will, by default, fime out in 3 minutes.
### It is adviceable to check that flows are cleared in CSS when > 3 minutes has passed after test has finished.
### Connection tracker only applies for SDN cases when using neutron security groups.

print ("This is pre-run to make sure that all learning is done before real test starts and that UDP flows are established in connection tracker")
setup_traffic(first_port = port_0, second_port = port_1, pps_lat_flows_loc = 1000, pkt_size_loc = 64, duration_loc = 60)
for i in size_array:
for j in range(init_pps, pps_limit [i] + 100000, 100000):
print ("PPS limit for frame size is: %s" % pps_limit [i])
test_fail_reason = "PPM limit not reached!"
setup_traffic(first_port = port_0, second_port = port_1, pps_lat_flows_loc = j, pkt_size_loc = i, duration_loc = init_duration)
if (1000000*flow1_PPM_loss <= ppm_limit) & (1000000*flow2_PPM_loss <= ppm_limit) & passed & ((j-1000)<=flow1_actual_pps) & ((j-1000)<=flow2_actual_pps):
print ("Success!")
print ( "%.1f PPM for Flow1 %.1f PPM for Flow2\n" % ( 1000000*flow1_PPM_loss, 1000000*flow2_PPM_loss))
max_pps [ i ] = j
else :
print("Failure!")
failed_pps [ i ] = j
if passed & ((j-1000)<=flow1_actual_pps) & ((j-1000)<=flow2_actual_pps):
test_fail_reason = "PPM to high!"
else:
test_fail_reason = "TREX resource problem!"
break
print (max_pps)

max_pps_coarse = max_pps.copy()
for i in size_array:
pps_limit [ i ] = int(((max_bw_per_flow*1000000000/((20+i)*8))//10000)*10000)
for i in size_array:
for j in range(10000, 100000, 10000):
setup_traffic(first_port = port_0, second_port = port_1, pps_lat_flows_loc = (j + max_pps_coarse [ i ]), pkt_size_loc = i, duration_loc = init_duration)
if (1000000*flow1_PPM_loss <= ppm_limit) & (1000000*flow2_PPM_loss <= ppm_limit) & passed & ((j + max_pps_coarse [ i ] - 1000) <=flow1_actual_pps) & ((j + max_pps_coarse [ i ] - 1000) <=flow2_actual_pps):
print ("Success!")
print ( "%.1f PPM for Flow1 %.1f PPM for Flow2\n" % ( 1000000*flow1_PPM_loss, 1000000*flow2_PPM_loss))
max_pps [ i ] = max_pps_coarse [ i ] + j
print (max_pps)
else :
print("Failure!")
failed_pps [ i ] = j + max_pps_coarse [ i ]
if passed & ((j + max_pps_coarse [ i ] - 1000) <=flow1_actual_pps) & ((j + max_pps_coarse [ i ] - 1000) <=flow2_actual_pps):
test_fail_reason = "PPM to high!"
else:
test_fail_reason = "TREX resource problem!"
break
if pps_limit [ i ] == max_pps [ i ]:
test_fail_reason = "Test setup Bandwidth limit reached!"
break
print (" ######################################\n")
print (" Starting final longer duration run for max pps per frame size found in earier test iterations!")
print (" Limit found when Failing %i PPM in pre-run: %s\n" % (ppm_limit, failed_pps))
print (" ######################################\n")
for i in size_array:
test_fail_reason_final = "PPM OK!"
setup_traffic(first_port = port_0, second_port = port_1, pps_lat_flows_loc = max_pps[i], pkt_size_loc = i, duration_loc = final_duration)

if (1000000*flow1_PPM_loss <= ppm_limit) & (1000000*flow2_PPM_loss <= ppm_limit) & passed & ((max_pps[i] - 1000)<=flow1_actual_pps) & ((max_pps[i] - 1000)<=flow2_actual_pps):
print ("Success!")
PPM_flow1 = 1000000*flow1_PPM_loss
PPM_flow2 = 1000000*flow2_PPM_loss
ppm_final_run_flow1 [i] = 1000000*flow1_PPM_loss
ppm_final_run_flow2 [i] = 1000000*flow2_PPM_loss

print ("Test for frame size Passed for %i Byte @ PPS: %i with PPM %.1f for flow1 and PPM: %.1f for flow2.\n" % (i, max_pps[i], PPM_flow1, PPM_flow2))
elif passed & ((max_pps[i] - 1000)<=flow1_actual_pps) & ((max_pps[i] - 1000)<=flow2_actual_pps):
failed_pps [ i ] = max_pps[ i ]
test_fail_reason_final = "PPM to high!"
print ("Reason for long run failure: %s\n" % test_fail_reason_final)
print ( "%.3f PPM for Flow1 %.3f PPM for Flow2\n" % ( 1000000*flow1_PPM_loss, 1000000*flow2_PPM_loss))
else:
failed_pps [ i ] = max_pps[ i ]
test_fail_reason_final = "TREX resource problem!"
print ("Reason for long run failure: %s\n" % test_fail_reason_final)

if test_fail_reason_final != "PPM OK!" :
ppm_final_run_flow1 [i] = "Working PPM not found"
if max_pps [ i ] >= 100000:
for j in range(1,10):
while test_fail_reason_final != "PPM OK!":
max_pps [ i ] = max_pps [ i ] - 10000
setup_traffic(first_port = port_0, second_port = port_1, pps_lat_flows_loc = max_pps[i], pkt_size_loc = i, duration_loc = final_duration)
if (1000000*flow1_PPM_loss <= ppm_limit) & (1000000*flow2_PPM_loss <= ppm_limit) & passed & ((max_pps[i] - 1000)<=flow1_actual_pps) & ((max_pps[i] - 1000)<=flow2_actual_pps):
print ("Success!")
PPM_flow1 = 1000000*flow1_PPM_loss
PPM_flow2 = 1000000*flow2_PPM_loss
print ("Test for frame size Passed for %i Byte @ PPS: %i with PPM %.1f for flow1 and PPM: %.1f for flow2.\n" % (i, max_pps[i], PPM_flow1, PPM_flow2))
test_fail_reason_final = "PPM OK!"
ppm_final_run_flow1 [i] = 1000000*flow1_PPM_loss
ppm_final_run_flow2 [i] = 1000000*flow2_PPM_loss
elif passed & ((max_pps[i] - 1000)<=flow1_actual_pps) & ((max_pps[i] - 1000)<=flow2_actual_pps):
failed_pps [ i ] = max_pps[ i ]
test_fail_reason_final = "PPM to high!"
print ("Reason for long run failure: %s\n" % test_fail_reason_final)
print ( "%.3f PPM for Flow1 %.3f PPM for Flow2\n" % ( 1000000*flow1_PPM_loss, 1000000*flow2_PPM_loss))
else:
failed_pps [ i ] = max_pps[ i ]
test_fail_reason_final = "TREX resource problem!"
print ("Reason for long run failure: %s\n" % test_fail_reason_final)


else:
print ( " Did not find working PPS/PPM for frame size %i !!!\n" % i)
print("################################################################################")
print("############################## Final results ###################################")
print("####### PPS found per Frame size and flow (Note: 2 flows with PPS as per below)#")
print(json.dumps(max_pps, indent = 2))
print("######################### PPS failed at following PPS per Frame size ###########")
print(json.dumps(failed_pps, indent = 2))
print("################### Final run PPM found per frame size and flow ################")
print("Flow1:")
print(json.dumps(ppm_final_run_flow1, indent = 2))
print("Flow2:")
print(json.dumps(ppm_final_run_flow2, indent = 2))

if __name__ == "__main__":

print("%.1f PPM througput, latency and jitter test started for %i UDP flows!" % (ppm_limit,flows))
for i in size_array:
max_pps [ i ] = 1000
failed_pps [ i ] = "N/A"
search_func(ppm_limit = ppm_limit, size_array = size_array, init_duration = init_dur, final_duration = final_dur)


BR/Håkan

[Yaroslav Brustinov]

Hi,

Thanks for your report and reproduction script.

Hopefully we have found the bug.

Please try out this branch (it has fixed the issue for me):

https://github.com/ybrustin/trex-core/tree/fs_ver_id_renew

Thanks,

Yaroslav.

--
You received this message because you are subscribed to the Google Groups "TRex Traffic Generator" group.
To unsubscribe from this group and stop receiving emails from it, send an email to trex-tgn+u...@googlegroups.com.
To post to this group, send email to trex...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/trex-tgn/013efc3f-8430-4239-911e-f4eef17fc135%40googlegroups.com.

[hakl...@gmail.com]

Hi, tried on v2.50 which I beleive also included your fix. Seems issue is solved.
Thanks/Håkan