Integrating Wireshark with UVM: A High-Level Overview
One of the key challenges in network simulation when working with UVM test benches is understanding the traffic flow and ensuring that packets are being correctly transmitted, received, and processed. To achieve this, packet capture tools like Wireshark have become incredibly valuable.
Wireshark provides in-depth analysis and visualization of packet-level interactions, making it an essential tool for debugging network behaviors. In this blog, we explore integrating Wireshark with UVM to capture and analyze packets live as they are generated in the testbench.
To achieve this, an agent that we’ll call PCAP is used as a translator between the format understood by Wireshark and the testbench, in this way, it’s easy to move this to a different testbench, also the agent is parametrized by a seq item, so it can be easily modified for different situations.
The Flow of Data
Here’s a high-level view of the data flow in this system:
The Core Idea: Stream Packets from UVM into Wireshark
The primary objective of this integration is to enable real-time packet capture and analysis by Wireshark, allowing you to visualize network traffic generated in your UVM testbench as it happens. At a high level, here’s how each part of the system works together:
- UVM Testbench – Packet capture
The UVM testbench is responsible for generating network traffic during simulation. The packets wanting to be analyzed are sent to the analysis port of the PCAP agent, which will give the proper formatting to them, necessary to get them to visualize in Wireshark. The packets could be anything from simple Ethernet frames to complex application-layer messages, depending on the nature of your simulation. The UVM testbench itself doesn’t interact directly with Wireshark. Instead, the agent writes the generated packets into a .pcap file format.- PCAP Writer: The pcap_writer class in UVM manages the creation of this .pcap file. It first populates it with a global header, in which the packet timestamps resolution is configured. Then it writes packet metadata such as timestamps, packet length, and other details that Wireshark needs for analysis along with the payload itself. This file serves as a snapshot of the network traffic that can be saved or replayed for inspection later.
- Python Script – Real-Time Streaming to Wireshark
Once the packets are written into the .pcap file, the next step is to stream that data to Wireshark for real-time analysis. This is where the Python script comes in. Its role is to read the .pcap file, extract the packet data, and send it over a communication channel (a pipe) to Wireshark.- Pipe Creation: The Python script creates a named pipe, a special kind of communication channel that allows data to be transferred between processes in real-time. In this case, the pipe is used to send packet data from the Python script to Wireshark.
- Wireshark Configuration: The Python script starts Wireshark with a command that instructs it to listen on this pipe. Wireshark is configured to automatically start capturing packets as soon as the pipe starts transmitting data. This allows for immediate analysis of the traffic generated by the UVM testbench.
- Packet Streaming: The Python script reads the .pcap file in chunks, and each chunk (representing a packet or a group of packets) is then written to the pipe. This effectively feeds Wireshark with a live stream of the network traffic generated during the simulation.
- Wireshark – Live Capture and Analysis
Wireshark, once started, listens to the pipe and begins to capture the incoming packet data. This real-time capture is key for debugging and inspecting network traffic dynamically as the simulation progresses.- Live Packet Capture: As the Python script streams packet data, Wireshark captures the traffic in real-time. Each packet is decoded, and its headers, payload, and other details are displayed in Wireshark’s graphical interface. The user can interactively inspect the captured packets, search for specific information, apply filters, and analyze the packet contents.
- Protocol Decoding: Wireshark’s powerful protocol analyzers can break down each packet according to the protocols it contains. For instance, Ethernet frames will be dissected into their MAC headers, while IP and TCP packets will be further analyzed to show IP addresses, ports, flags, and other relevant details.
Why This Approach is Effective
- Real-Time Monitoring: The combination of UVM and Wireshark’s real-time capture provides immediate visibility into the network traffic. This approach is ideal for debugging, as you don’t need to wait for the simulation to finish before you start inspecting the packets.
- Detailed Analysis: With Wireshark, you gain access to a powerful suite of packet analysis tools. This enables detailed inspection of every aspect of the traffic, from protocol headers to payloads, and gives you a more granular view of the behavior of your system.
- Seamless Integration: The use of pipes allows the system to operate in a continuous, dynamic loop. The simulation runs while packets are being captured live by Wireshark, without the need for manual intervention or post-simulation file analysis.
- Flexibility and Scalability: This approach is flexible enough to be used for different types of network traffic, from simple Ethernet packets to more complex, application-level traffic. Additionally, because the system is built around UVM and standard tools like Wireshark, it can be easily extended and adapted for different types of simulations or analysis.
Conclusion
Integrating Wireshark with a UVM testbench is a powerful way to enhance your simulation and debugging process. By streaming generated packets in real-time from UVM to Wireshark using a pipe, you can analyze network traffic dynamically as the simulation progresses. This live capture setup provides immediate visibility into packet-level interactions, making it an invaluable tool for verifying network behavior and troubleshooting complex issues in your testbench.
Through the combination of UVM for packet generation, Python for data streaming, and Wireshark for analysis, this integration unlocks a new level of insight into the behavior of your networked system, allowing you to identify and resolve issues more efficiently and effectively.
In the last installment of this three part blog, we will show this example working along the TLP (Transaction Layer Packet) generator in Python. This way we will be able to easily analyze complex packets that otherwise would be too complex in UVM only.
Written by Joaquin Lutri and Martin Sarasqueta Fierens
Design Verification Engineers at Emtech S.A.
Thanks Marcelo Pouso for their valuable feedback and insightful reviews.
For further information, contact us: info@emtech.com.ar