A data sender in an IP-based network is only capable of efficiently using a network path if it knows the packet size limit of the path, i.e., the Path Maximum Transmission Unit (PMTU). An IP router that cannot forward and must drop an oversized packet should notify the sender with a Packet Too Big (PTB) message, which contains the maximum packet size it can forward. A transport protocol supporting a discovery to determine the PMTU may use PTB messages. However, for the transport protocol QUIC (e.g., used by HTTP/3), we identified only a few implementations that determine the PMTU and none of them process PTB messages. In this paper, we present results from simulations that show how much a QUIC sender using PMTU discovery benefits from processing PTB messages, which includes a result that outlines the benefit of determining the PMTU in general. Further, we analyze the risk of using PTB messages and describe a way to protect against potential attacks with forged PTB messages.

RACK for TCP is a loss detection and recovery algorithm which relies on the notion of time instead of counting packet losses. The algorithm has been integrated in Microsoft Windows, Linux and FreeBSD as a full-featured alternative to the existing TCP loss recovery algorithms. Cheng et al. claim that the algorithm offers a significant improvement, especially for tail losses and cases with packet reordering within the network. We adopted RACK for the SCTP protocol and improved its mechanisms by utilizing built-in SCTP specific features. To evaluate the benefits and drawbacks of RACK and our modifications to the algorithm, we integrated RACK in the SCTP model of the OMNeT++/INET simulation environment. Our simulations show a positive impact in common networking scenarios regarding loss recovery and reordering tolerance.

One of only two new transport protocols introduced in the last 30 years is the Stream Control Transmission Protocol (SCTP). SCTP enables capabilities like additional throughput and fault tolerance for multihomed hosts. An SCTP implementation is included with the Linux kernel and another implementation called sctplib functions successfully in userspace on several platforms but unfortunately neither of these implementations have all of the latest features nor do they perform as well as the FreeBSD kernel implementation of SCTP. We were motivated to produce a portable implementation of the FreeBSD kernel SCTP stack that operates in userspace of any system because of both our desires to obtain a higher performance SCTP stack for Linux as well as to exploit recent developments in hardware virtualization and transport protocol onloading. Unlike any other userspace transport implementation for TCP or SCTP, our userspace SCTP stack simultaneously achieves similar throughput and latency as the Linux kernel TCP stack, without compromising on any of the transport's features as well as maintaining true portability across multiple operating systems and devices. We create a callback API and implement a threshold to control its usage; our userspace SCTP stack with these optimizations obtains higher throughput than the Linux kernel implementation of SCTP. We describe our userspace SCTP stack's design and demonstrate how it gives similar throughput and latency on Linux as the kernel TCP implementation, with the benefits of the new features of SCTP.

With the deployment of more and more resilience-critical Internet applications, there is a rising demand for multi-homed network sites. This leads to the desire for simultaneously utilising all available access paths to improve application data throughput. This is commonly known as Concurrent Multipath Transfer (CMT); approaches for several Transport Layer protocols have been proposed. Combined with Resource Pooling (RP), CMT can also fairly coexist with concurrent non-CMT flows. Current approaches focus on symmetric paths (i.e. similar bandwidth, delay and error rate). However, asymmetric paths are much more likely - particularly for realistic Internet setups - and efficient CMT usage on such paths is therefore crucial. In this paper, we first show the challenges of plain as well as RP-aware CMT data transport over asymmetric paths. After that, we introduce mechanisms for efficient transport over such paths. Finally, we analyse the performance of our approaches by using simulations.

In general, the Stream Control Transmission Protocol (SCTP) delays the sending of acknowledgments. For specific cases, this results in non-optimal protocol behavior. Therefore, the protocol specification defines several exceptions that allow the receiver of an SCTP packet containing user data to send the corresponding acknowledgment without delaying it. However, all these exceptions only take the status at the user data receiver side into account and thus cannot cover all relevant situations. To overcome this limitation, the authors have proposed a generic mechanism allowing the sender of an SCTP packet containing user data to indicate, that the corresponding acknowledgment should not be delayed. This paper analyzes the benefits of using this sender side mechanism under several conditions.

Programs that execute in parallel across a network often use the Message Passing Interface (MPI) library for communication. The network requirements of an MPI program are often unclear because of the difficulty in exploring alternative network configurations as well as obtaining packet level information about the communication. MPI-NeTSim is an execution environment to emulate MPI programs on simulated networks to allow users to better explore the impact of the network on the performance of MPI programs. We describe the design of MPI-NeTSim and the integration of OMNeT++’s INET framework into MPICH2’s MPI middleware. We introduce a novel technique for uniformly slowing down the execution of the system to allow the discrete event network simulator to keep up with the execution and provide a consistent view of the communication. We validate our technique with synthetic programs as well as the standard NAS benchmarks. We demonstrate MPI-NeTSim’s usefulness in analyzing the effect of the network on communication by using our environment to study the impact of a slow-link on the NAS benchmarks.

In this contribution we present a new type of mobility management for IP-based networks that, contrary to conventional approaches, does not focus on the network layer, but on the transport and session layers. At the heart of this new mobility concept is the reliable transport protocol SCTP, with an enhancement for dynamic address reconfiguration. The reliable server pooling (RSerPool) protocol suite provides a service for session monitoring and control. The suggested solution is transparent for applications, requires no changes in the network infrastructure, and is evaluated with a real-world implementation. Finally, we present first results from the application of this mobility concept to different mobility scenarios. These were obtained from working SCTP and RSerPool implementations that have been developed within our group.