Skip to content

[COPP] Improve RX PPS Calcuation for COPP Tests #21705

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
ccroy-arista wants to merge 2 commits into
base: master
Choose a base branch
from
Open

[COPP] Improve RX PPS Calcuation for COPP Tests #21705

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
f436ec1
Improve RX PPS Calcuation for COPP Tests
ccroy-arista Dec 6, 2025
c19cf2c
Fix COPP ARP Test
ccroy-arista Dec 9, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
69 changes: 34 additions & 35 deletions ansible/roles/test/files/ptftests/py3/copp_tests.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -156,48 +156,48 @@ def copp_test(self, packet, send_intf, recv_intf):
self.log("Send %d and receive %d packets in the first second (PolicyTest)" % (
pre_send_count, rcv_pkt_cnt))

pre_test_ptf_tx_counter = self.dataplane.get_counters(*send_intf)
pre_test_ptf_rx_counter = self.dataplane.get_counters(*recv_intf)
pre_test_nn_tx_counter = self.dataplane.get_nn_counters(*send_intf)
pre_test_nn_rx_counter = self.dataplane.get_nn_counters(*recv_intf)

start_time = datetime.datetime.now()
end_time = datetime.datetime.now(
) + datetime.timedelta(seconds=self.DEFAULT_SEND_INTERVAL_SEC)

send_count = 0
first_capture_complete = False
second_capture_complete = False
datetime_five_seconds = datetime.timedelta(seconds=5)
datetime_fifteen_seconds = datetime.timedelta(seconds=15)
self.dataplane.flush()
while datetime.datetime.now() < end_time:
start_time = datetime.datetime.now()
end_time = start_time + datetime.timedelta(seconds=self.DEFAULT_SEND_INTERVAL_SEC)
while datetime.datetime.now() < end_time + datetime_fifteen_seconds:
testutils.send_packet(self, send_intf, packet)
send_count += 1

if not first_capture_complete and datetime.datetime.now() > start_time + datetime_five_seconds:
first_capture_complete = True
pre_test_ptf_tx_counter = self.dataplane.get_counters(*send_intf)
pre_test_ptf_rx_counter = self.dataplane.get_counters(*recv_intf)
pre_test_nn_tx_counter = self.dataplane.get_nn_counters(*send_intf)
pre_test_nn_rx_counter = self.dataplane.get_nn_counters(*recv_intf)
first_capture_time = datetime.datetime.now()
elif not second_capture_complete and datetime.datetime.now() > end_time - datetime_five_seconds:
second_capture_complete = True
post_test_ptf_tx_counter = self.dataplane.get_counters(*send_intf)
post_test_ptf_rx_counter = self.dataplane.get_counters(*recv_intf)
post_test_nn_tx_counter = self.dataplane.get_nn_counters(*send_intf)
post_test_nn_rx_counter = self.dataplane.get_nn_counters(*recv_intf)
second_capture_time = datetime.datetime.now()

# Depending on the server/platform combination it is possible for the server to
# overwhelm the DUT, so we add an artificial delay here to rate-limit the server.
time.sleep(1.0 / float(self.default_server_send_rate_limit_pps))

self.log("Sent out %d packets in %ds" %
(send_count, self.DEFAULT_SEND_INTERVAL_SEC))

self.log("Sent out %d packets in %ds" % (send_count, self.DEFAULT_SEND_INTERVAL_SEC))
# Wait a little bit for all the packets to make it through
time.sleep(self.DEFAULT_RECEIVE_WAIT_TIME)
recv_count = testutils.count_matched_packets_all_ports(
self, packet, [recv_intf[1]], recv_intf[0], timeout=self.PTF_TIMEOUT)
self.log("Received %d packets after sleep %ds" %
(recv_count, self.DEFAULT_RECEIVE_WAIT_TIME))

post_test_ptf_tx_counter = self.dataplane.get_counters(*send_intf)
post_test_ptf_rx_counter = self.dataplane.get_counters(*recv_intf)
post_test_nn_tx_counter = self.dataplane.get_nn_counters(*send_intf)
post_test_nn_rx_counter = self.dataplane.get_nn_counters(*recv_intf)

ptf_tx_count = int(
post_test_ptf_tx_counter[1] - pre_test_ptf_tx_counter[1])
nn_tx_count = int(
post_test_nn_tx_counter[1] - pre_test_nn_tx_counter[1])
ptf_rx_count = int(
post_test_ptf_rx_counter[0] - pre_test_ptf_rx_counter[0])
nn_rx_count = int(
post_test_nn_rx_counter[0] - pre_test_nn_rx_counter[0])
self.log("Received %d packets after sleep %ds" % (recv_count, self.DEFAULT_RECEIVE_WAIT_TIME))

ptf_tx_count = int(post_test_ptf_tx_counter[1] - pre_test_ptf_tx_counter[1])
nn_tx_count = int(post_test_nn_tx_counter[1] - pre_test_nn_tx_counter[1])
ptf_rx_count = int(post_test_ptf_rx_counter[0] - pre_test_ptf_rx_counter[0])
nn_rx_count = int(post_test_nn_rx_counter[0] - pre_test_nn_rx_counter[0])

self.log("", True)
self.log("Counters before the test:", True)
Expand All @@ -217,11 +217,10 @@ def copp_test(self, packet, send_intf, recv_intf):
self.log("Recv from If on remote ptf_nn_agent: %d" % ptf_rx_count)
self.log("Recv from NN on from remote ptf_nn_agent: %d" % nn_rx_count)

time_delta = end_time - start_time
time_delta_ms = (time_delta.microseconds +
time_delta.seconds * 10**6) / 1000
tx_pps = int(send_count / (float(time_delta_ms) / 1000))
rx_pps = int(recv_count / (float(time_delta_ms) / 1000))
time_delta = second_capture_time - first_capture_time
time_delta_ms = (time_delta.microseconds + time_delta.seconds * 10**6) / 1000
tx_pps = int(nn_tx_count / (float(time_delta_ms) / 1000))
rx_pps = int(nn_rx_count / (float(time_delta_ms) / 1000))

return send_count, recv_count, time_delta, time_delta_ms, tx_pps, rx_pps

Expand Down Expand Up @@ -298,7 +297,7 @@ def runTest(self):
def construct_packet(self, port_number):
src_mac = self.my_mac[port_number]
src_ip = self.myip
dst_ip = self.peerip
dst_ip = "169.254.254.254" # Non-existent IP to avoid triggering ARP response trap

packet = testutils.simple_arp_packet(
eth_dst='ff:ff:ff:ff:ff:ff',
Expand Down
Loading