TSN 仿真/仿真环境中的延迟与抖动表征

\PARstart Timestamping frames is central to network profiling. It is primarily performed using network analyzers in physical networks. Profiling network traffic in software has become crucial in emulated and containerized environments (e.g., Docker, Kubernetes, CNI plugins), bridging and tunneling, and cloudification. It enables the use of different procedures for recording various timer values at different software layers, each with distinct overheads and trade-offs. The goal of this work is to explore and compare four different timestamping methods. We conduct our study in the context of Time-Sensitive Networking (TSN) emulation, but our methods and findings are applicable to a wide range of network emulation scenarios, including containerized networks and tunneling systems.

Time-Sensitive Networking (TSN) constitutes a set of IEEE standards at the Data Link layer aimed at achieving deterministic and ultra-fast transmissions over standard Ethernet and wireless technologies, capable of integrating different types of traffic. Current proprietary industrial networks are migrating to this new open and interoperable paradigm. TSN is at the basis of Industry 4.0, new intra-vehicle networks in automotive and aerospace industries, and the future Deterministic Internet.

TSN offers traffic shaping to maintain quality of service in networks where time-sensitive streams with varying criticalities coexist with best-effort traffic. Particularly, we focus on the IEEE 802.1Qbv shaper (TAS) [ 1 ]. The quest for optimal routing and scheduling solutions for specific use cases still remains open, particularly when it comes to implementing a scheduling solution in actual networks. This implementation requires a verification process that often necessitates revising the schedule due to estimates provided to the theoretical scheduling problem. Utilizing a physical testbed demands significant time and resources, and simulation may not be practical due to the complexity of certain use cases. In this research, we focus on emulation, which aligns with the trend towards Software-Defined Networks (SDN) and cloudification, where physical testbeds are not available.

To this end, we leverage the Mininet [ 2 ] network emulator. It allows the definition and emulation of network nodes (hosts —TSN end points—, and bridges) and links on a single Linux system. Hosts in Mininet behave as the physical ones. The net can be administered through common tools (e.g., nm). User applications can send and receive frames through virtual interfaces such as veth, going through Mininet bridges (which can functionally act as switches). Both the emulated and the physical system can run the same binaries. Fig. 1 provides an overview of our TSN emulation setup and highlights the issues we address here. First, we define and configure the network: hosts, bridges, links, and TSN streams (talker and listener nodes, jitter and deadline bounds). Second, we characterize bridge latencies and the intrinsic jitter of this network. Third, we solve the TSN scheduling problem for those streams, taking into account the stream definitions, and the latencies and intrinsic jitter we measured in the emulated network. Then, we deploy the schedule configuring the TAS of the bridges. Finally, we start the system, collecting indicators to assess the correctness of the schedule.

This work provides the following contributions: • A software timestamping methodology to measure end-to-end and bridge latencies, comparing options suitable for any network emulation and containerized networks, among others. • Solutions to the principal issues underlying the Linux and Mininet setup for TSN emulation. As far as we know and as of this writing, this is the only work which explicitly provides pivotal configuration details for TSN emulation on Mininet. • Experimental evidence leading to useful hints to conveniently setup the underlying emulation platform (Linux plus microprocessor) with and without Intel ® ’s TCC ®, either on a high-end workstation or on an industrial PC.

A software timestamping methodology to measure end-to-end and bridge latencies, comparing options suitable for any network emulation and containerized networks, among others.

Solutions to the principal issues underlying the Linux and Mininet setup for TSN emulation. As far as we know and as of this writing, this is the only work which explicitly provides pivotal configuration details for TSN emulation on Mininet.

Experimental evidence leading to useful hints to conveniently setup the underlying emulation platform (Linux plus microprocessor) with and without Intel ® ’s TCC ®, either on a high-end workstation or on an industrial PC.

In which follows, we review a few close contributions in Sec. 2. Secs. 3 and 6 introduce solutions to the Linux and Mininet issues related to TSN emulation, and timestamping related background. Sec. 7 describes the experimental environment. Sec. 8 analyzes timestamping methods to characterize latencies at different levels and jitter, considering different platform configurations. Sec. 9 applies the characterization methodology to a Use Case, revealing and solving a few final problems. Sec. 10 provides conclusions and remarks.

There is a limited number of works related to the issues of emulating TSN on Mininet [ 3 ] [ 4 ]. Both identify —and do not always resolve— integration problems of TSN components on Mininet bridges. The authors in [ 5 ] develop a measurement methodology comparing a software implementation of the TAS with a hardware testbed, but they provide no details.

TSN emulation on Mininet is also leveraged in [ 6 ], focusing on the SDN capabilities of Mininet rather than on the TSN mechanisms implemented in Linux. They develop a profiling methodology, whose approach differs from that of [ 5 ] but obtains similar results. Also, there is an interesting summary of most TSN utilities existing in Linux in [ 7 ].

We exploit three key components to support TSN on Mininet: XDP (eXpress Data Path) [ 8 ], AF_PACKET [ 9 ] and qdisc (Linux queue disciplines) (Fig. 2).

XDP allows the execution of user-level filters using the BPF interface [ 10, 11 ]. These filters are attached to a kernel hook right after the interrupt service routine which triggers upon each frame arrival, in a physical system, or just into the veth driver in an emulated node. The XDP routine can examine the frame and either drop it, copy it to user space, or forward it to another Network Interface Controller (NIC). AF_PACKET clones the frame and sends the copy to a user process, while the kernel’s copy of the frame (sk_buff) proceeds to the Linux Network Stack (LNS).

Qdisc is a Linux framework, managed with the tc tool, to place predefined filters between an ingress (egress) port and the LNS. The key qdisc for TSN is the taprio qdisc, intended to emulate a simplified version of an IEEE 802.1Qbv TAS (Fig. 3). Besides taprio, we also leverage clsact for the complete integration of the taprio qdisc, in order to meet TSN common practices (Sec. 4), and netem to emulate the transmission time (Sec. 9.1).

Mininet runs on a single Linux computer. This obviates the emulation of IEEE 802.1AS devices to meet the TSN time-synchronization requirements, resulting in a zero clock skew. Each network node (host or bridge) is a user process, which forks children processes as required (e.g., talkers and listeners at the end-stations). Network links among nodes are set up leveraging the virtual Ethernet driver veth. This virtual driver emulates the Data Link Layer firmware of the NICs, and serves as the OS Ethernet driver itself. All processes in a node share a single LNS and the same Linux namespace. Mininet imposes no requirement on the kernel preemption mode. We have opted for a fully preemptible kernel (RT) configuration, common in TSN nodes.

Configuring Mininet involves installing and setting up the taprio qdisc, which emulates the queue structure of IEEE 802.1Qbv. However, the veth driver defaults to a single queue, which is manageable for one class but requires kernel patching to overcome this limitation [ 12 ]. Additionally, frames in TSN need to be identified by the traffic class of their respective streams. TSN bridges commonly utilize the PCP subfield within the VLAN tag of the Ethernet frame for this purpose. Although Mininet does not natively support virtual LANs, we can modify the Host class in the Mininet framework to enable the VLAN field.

In TSN, frames are tagged with their corresponding class ID at the talker’s host. We do that leveraging the iptables tool of Linux, which stores the ID in the priority field of the sk_buff allocated to the frame (sk_buff → → \rightarrow → priority), for every stream sent through a specific egress port. Then, actual VLAN interfaces pass this ID to the PCP field of the Ethernet package. We have configured the veth interfaces at the egress ports of Mininet hosts with VLAN support, so they can proceed the same way.

The veth interfaces at the ingress ports of Mininet bridges cannot be configured with VLAN capabilities; otherwise, they would strip the VLAN header. Since taprio determines the class ID of frames based on their sk_buff → → \rightarrow → priority field, we employ the clsact qdisc to copy the PCP value of incoming frames into their sk_buff → → \rightarrow → priority field. Fig. 4 provides an overview of our approach, illustrating how filters and qdiscs are used to emulate TSN within Mininet.

As per time synchronization, we already mentioned that Mininet runs on a single Linux instance. Therefore, all processes can share the same clocking with no clock skew and no explicit emulation of the IEEE 802.1AS protocol.

Intel’s Time Coordinated Computing (TCC ®) [ 13 ] encompasses a set of optimizations in order to improve the real-time performance of the underlying platform. • Power State Transition Optimizations limit the jitter in CPU execution due to frequency changes, and other power-saving features. • Memory/Cache Allocation Optimizations reduce the variability of the memory subsystem by allowing to partition the shared caches, including the portions available to the GPU. • Interrupt Request (IRQ) Optimizations streamline the critical path for interrupts in the CPU core, and also allow devices to deliver interrupts directly to the guest OS. • Fabric and PCIe Virtual Channels provide different priorities for the transactions related to different workloads, allowing to treat real-time traffic as high priority. • Intel ® Speed Shift for Edge Compute Applications enables specific assignment of processor performance to where it is most needed. • Precision Time Coordination and PCIe Precision Time Measurement (PTM) allow to coordinate events across multiple SoC subsystems and components with independent time clocks.

Power State Transition Optimizations limit the jitter in CPU execution due to frequency changes, and other power-saving features.

Memory/Cache Allocation Optimizations reduce the variability of the memory subsystem by allowing to partition the shared caches, including the portions available to the GPU.

Interrupt Request (IRQ) Optimizations streamline the critical path for interrupts in the CPU core, and also allow devices to deliver interrupts directly to the guest OS.

Fabric and PCIe Virtual Channels provide different priorities for the transactions related to different workloads, allowing to treat real-time traffic as high priority.

Intel ® Speed Shift for Edge Compute Applications enables specific assignment of processor performance to where it is most needed.

Precision Time Coordination and PCIe Precision Time Measurement (PTM) allow to coordinate events across multiple SoC subsystems and components with independent time clocks.

A usual timestamping point is the boundary between the physical layer (PHY) and the medium (e.g., an Ethernet cable). Specialized hardware probes like network TAP devices allow the capture of such measurements. NICs may also include timestamping mechanisms that approximate those values. Some NICs include the ability to timestamp DMA requests as well. The OS can retrieve timestamps from devices (hardware timers at the microprocessor or NICs).

Linux stores a few hardware timestamps in the sk_buff per-frame structure, along with software timestamps, which can be reached leveraging XDP, or the recvmsg() syscall via sockets AF_PACKET or AF_INET. The OS does also generate timestamps generated from OS-managed hardware timers, abstracted as OS clocks, such as CLOCK_REALTIME, CLOCK_TAI or CLOCK_MONOTONIC and others, reachable through the clock_gettime() syscall, or a BPF helper function such as bpf_ktime_get_ns() called from an XDP program. It is pivotal to note that hardware counters may hold time values (e.g., in nanoseconds), or simply a number of ticks that must be translated to time values using a given frequency, as Linux does to provide clock abstractions like the ones we have just mentioned. When it comes to networking, a typical hardware element used for timestamping is the PTP Hardware Clock (PHC) [ 14 ]. Linux offers an ioctl interface that allows to relate the timestamps taken by the NIC and its own time-keeping mechanisms.

The hardware architecture provides specific timestamping mechanisms and ISA interfaces. For example, Intel 64 and IA-32 architectures define the operation of a Timestamp Counter (TSC), and instructions like rdtsc to read it [ 15 ]. The OS will normally use such architecture support as the foundation of its own time-keeping mechanisms.

Tab. 1 summarizes the three experimental setups we use in this work. C1 employs a preeemptable kernel configuration, with no special optimization for real-time (RT), whereas C2 and C3 run a kernel with the PREEMPT_RT patch, configured with full RT preemption. The kernel in C2 is parameterized following Intel ® ’s recommendations for RT. C3 runs with the Intel ® ’s TCC ® system activated.

We deploy 1000 random frames from talker to listener traversing two bridges for the characterization and evaluation measurements performed in Sec. 8, with taprio configured with all queues open to avoid delaying any frame. The TSN topology and streams of the use case are described in Sec. 9, with taprio configured according to the computed schedule. The default configuration is C2 unless stated otherwise.

Among the timestamping possibilities introduced in Sec. 6, we have shortlisted the ones compatible with the veth framework, which actually emulates a NIC besides acting as the NIC driver, and with the timestamping points most appropriate to obtain the value of the delays under consideration.

Fig. 5 shows the points where we record timestamps, along with the calculated latencies. Tab. 2 defines each timestamp and the method(s) used to read them.

We leverage three timestamping methods: M1 reads the values of either CLOCK_REALTIME (M1.1) or CLOCK_MONOTONIC (M1.2) using the clock_gettime() syscall. M2 records the CLOCK_REALTIME value stored in the sk_buff by veth_xmit() at veth pairs, in kernel space. M2.1 records the timer value using a socket AF_INET (SOCK_DGRAM) from user space. M2.2 records the timer value using a socket AF_PACKET from user space. AF_PACKET clones the sk_buff and sends a copy to user space whereas the frame proceeds as usual through the LNS, where it can be validated. M3 records the value of a CLOCK_MONOTONIC timer in kernel space, using a BPF helper function bpf_ktime_get_ns() through the XDP framework.

reads the values of either CLOCK_REALTIME (M1.1) or CLOCK_MONOTONIC (M1.2) using the clock_gettime() syscall.

records the CLOCK_REALTIME value stored in the sk_buff by veth_xmit() at veth pairs, in kernel space.

M2.1 records the timer value using a socket AF_INET (SOCK_DGRAM) from user space. M2.2 records the timer value using a socket AF_PACKET from user space. AF_PACKET clones the sk_buff and sends a copy to user space whereas the frame proceeds as usual through the LNS, where it can be validated.

records the timer value using a socket AF_INET (SOCK_DGRAM) from user space.

records the timer value using a socket AF_PACKET from user space. AF_PACKET clones the sk_buff and sends a copy to user space whereas the frame proceeds as usual through the LNS, where it can be validated.

records the value of a CLOCK_MONOTONIC timer in kernel space, using a BPF helper function bpf_ktime_get_ns() through the XDP framework.

There are two relevant latencies we must calculate for TSN scheduling. First, the definition of each time-aware stream s i subscript 𝑠 𝑖 s_{i} italic_s start_POSTSUBSCRIPT italic_i end_POSTSUBSCRIPT, in a set of i 𝑖 i italic_i time-aware streams, includes a maximum allowed delay D i subscript 𝐷 𝑖 D_{i} italic_D start_POSTSUBSCRIPT italic_i end_POSTSUBSCRIPT and jitter J i subscript 𝐽 𝑖 J_{i} italic_J start_POSTSUBSCRIPT italic_i end_POSTSUBSCRIPT for the stream. For all frames of stream s i subscript 𝑠 𝑖 s_{i} italic_s start_POSTSUBSCRIPT italic_i end_POSTSUBSCRIPT, the delay d i, j subscript 𝑑 𝑖 𝑗 d_{i,j} italic_d start_POSTSUBSCRIPT italic_i, italic_j end_POSTSUBSCRIPT of each frame j 𝑗 j italic_j must be equal or lower than D i subscript 𝐷 𝑖 D_{i} italic_D start_POSTSUBSCRIPT italic_i end_POSTSUBSCRIPT. In TSN scheduling, such delay (and its jitter) refers to the time span we measure in the emulated system as e2e.nic (T ⁢ 4 − T ⁢ 1 𝑇 4 𝑇 1 T4-T1 italic_T 4 - italic_T 1, Fig. 5). Thus, the TSN schedule deployed in the emulated system is correct if the actual e2e.nic value measured for every frame j 𝑗 j italic_j is such that d i, j ≤ subscript 𝑑 𝑖 𝑗 absent d_{i,j}\leq italic_d start_POSTSUBSCRIPT italic_i, italic_j end_POSTSUBSCRIPT ≤ e2e.nic.

Second, in order to correctly calculate the gate opening and closing times synthesized as GCL entries in the IEEE 802.1Qbv TAS (Fig. 3), the scheduling algorithm must take into account the intrinsic jitter of the physical (or emulated) TSN system. The two main factors of this intrinsic jitter are the clock skew (which is zero in Mininet, Sec. 4) and the bridge latency. Actual TSN bridges have no user processes. In Mininet bridges, we deploy an instrumental user process which only runs when we activate profiling, using M2.2 and M3 to measure the bridge latency (br1L for any intermediate bridge, and br2L for the last bridge before the listener’s end station as in Fig. 5).

We have also instrumented the profiling system to calculate sendL, arrL, and e2e, useful to get an insight on the ways a frame can be processed in Linux.

Fig. 6 shows that the bridge latency (brL1) and average jitter measured using M2.2 (AF_PACKET) is slightly higher and with greater IQR than using M3 (AF_PACKET), due to the cloning performed by the latter. XDP yields a greater absolute jitter if we consider the outliers. Differences are actually negligible (a few μ 𝜇 \mu italic_μ s), favoring AF_PACKET (M2.2) because XDP (M3) is much harder to implement.

The leftmost box plot in Fig. 7 shows e2e.nic measured using M1.1 for T ⁢ 1 𝑇 1 T1 italic_T 1 and M2 for T ⁢ 4 𝑇 4 T4 italic_T 4, with timestamping turned off in bridges. It provides an estimate of the overhead introduced by XDP (M3) and AF_PACKET (M2.2) when timestamping is active at brL1 and brL2. Again, practical differences between XDP and AF_PACKET are negligible. Also, we can estimate the overhead of bridge timestamping while measuring end2end.nic in about 10 μ 𝜇 \mu italic_μ s.

We have compared our methodology over the three platform configurations summarized in Tab. 1. The RT optimizations in C2 yield lower latency values across all timestamping methods, despite a few outliers (Fig. 8). With C3, values decrease even further, necessitating a rescaling of the y 𝑦 y italic_y -axis to better visualize the impact (note the C3 dashed line at about 150 μ 𝜇 \mu italic_μ s superimposed as a reference). We detail results with C3 in Fig. 9, marking the C3 reference given in Fig. 8 (150 μ 𝜇 \mu italic_μ s), varying now the way we allocate processes to the four cores available in C3. Although the values per latency type roughly hold no matter the allocation, the middle plot (Allocation 2) eliminates the extreme outliers seen in other allocation schemes. We use XDP (M3) at T ⁢ 2 𝑇 2 T2 italic_T 2, T ⁢ 3 𝑇 3 T3 italic_T 3, and T ⁢ 4 𝑇 4 T4 italic_T 4 in Fig. 8 and AF_PACKET (M2.2) in Fig. 9 but the results hold, with negligible variations.

We now deploy a simple TSN use case to achieve three key objectives (Tab. 3, Fig. 10). First, we validate the timestamping methodology outlined in Sec. 8. Second, we wrap-up and test the TSN emulation settings described in Secs. 3 and 4. Finally, we demonstrate that the emulation platform and methodology can support the optimization of TSN scheduling design and deployment.

We solve the TAS scheduling problem according to the method in [ 16 ]. The solver requires the four per-stream parameters shown in Tab. 3 plus their paths (traversed bridges, Fig. 10).

Also, solving the scheduling problem requires considering four network parameters: transmission time, propagation time, bridge latency, and intrinsic jitter (which includes clock skew, talker delay, and NIC/ veth jitter). The transmission time is the interval from when the Time-Aware Shaper (TAS) begins transmitting a frame through an open gate to the physical medium until the transmission completes (Fig. 3). The propagation time (also known as propagation delay) is the time it takes for a signal to travel from the sender to the receiver across a physical communication channel.

In Mininet, the veth driver (Sec. 3) emulates the physical channel, meaning any parameter related to the latter may require kernel modifications. This is the only method we have found to accurately emulate propagation time. However, since propagation time is not central to our goals, we choose to omit it in our platform. Instead, we have devised a workaround to emulate transmission time by instantiating a netem qdisc as a child of taprio, as illustrated in Fig. 4. A drawback of this approach is that the first frame entering each netem queue is lost. Specifically, the first frame of stream 0 in Fig. 10 disappears at B1, and the second disappears at B2. To mitigate this, we perform a dry run before starting the profiling process.

As stated in Sec. 4, there is no clock skew in this experimental platform. To measure the talker delay, we have recorded the actual transmission times at talkers’ ends-tations, obtaining that the maximum difference with the scheduled transmission times is about 80 80 80 80 ns. The jitter at bridges is of about 200 ⁢ μ 200 𝜇 200\leavevmode\nobreak\ \mu 200 italic_μ s (Fig. 6), and the jitter in e2e.nic latency is around 10 ⁢ μ 10 𝜇 10\leavevmode\nobreak\ \mu 10 italic_μ s. Upon these figures, we estimate in 500 ⁢ μ 500 𝜇 500\leavevmode\nobreak\ \mu 500 italic_μ s the intrinsic jitter of our Mininet emulation platform.

Physical TSN systems are usually configured and run through a user network interface known as CUC (Centralized User Configuration), operating upon a Centralized Network Configuration component (CNC) which performs the actual configuration and boots the system. We do this job through a Python script which sets up the network (Mininet hosts, bridges and links, user processes), configures the CGLs in the taprio qdiscs of the bridges, defines a timestamp as instant zero, and sets all processes in waiting state. When instant zero is reached, all processes start.

Fig. 11 plots the values of e2e.nic for the three streams of the use case (configuration C2. Timestamping activated in bridges: AF_PACKET, M2.2). All measured latencies are in the order of μ 𝜇 \mu italic_μ s, an order of magnitude below the deadlines of the streams.

We have also checked that the time windows at TAS (taprio) gates are wide enough for the frames to pass-through. Fig. 12 shows that the gates at the taprio in bridge 1 allocated to streams 1 (green) and 0 (blue) open for enough time to ensure that the frames of the streams correctly pass-through. This means that the schedule solution has correctly taken into account transmission times and the intrinsic jitter of the platform.

We have successfully set up a Mininet/Linux environment suitable for TSN emulation, with a timestamping methodology that allows the characterization of the latencies of the emulated network (bridge latency, intrinsic jitter). As an application example, and to complete the necessary configuration steps, we have tested the schedule of a use-case on an emulated TSN network, solving the issue of emulating transmission times leveraging the netem Linux qdisc. Emulating the propagation delay requires the modification of the kernel, nevertheless.

Using XDP for timestamping yields slightly better latency bounds than using AF_PACKET, although differences are negligible as far as e2e.nic (the end-to-end latency which actually counts in TSN scheduling) is concerned.

Using XDP for timestamping offers slightly improved latency bounds over AF_PACKET, but the differences in e2e.nic, the end-to-end latency relevant to TSN scheduling, are minimal, and AFP is significantly easier to use. Leveraging a fully preemptible kernel along with Intel ® ’s TCC ® reduces substantially the intrinsic jitter in all cases. However, outcomes depend on the process-to-core allocation scheme, which is crucial for industrial PCs with few cores.

We have experimented a number of compatibility issues when installing, configuring and adapting the necessary tools and frameworks (kernel and gcc versions, veth, qdiscs, Mininet itself among others). Improvements are in the line of updating veth to integrate taprio and the etf qdisc, emulating the transmission time and updating hardware platforms.

This work was supported by the Spanish MCIN /AEI /10.13039 /501100011033 (grant PID2022 -136454NB-C22),by Government of Aragon (research group T58_23R) and by Instituto de Investigación en Ingeniería de Aragón (I3A, Conv. de Ayudas a Prácticas con TFG 2023)