40 research outputs found
Checking-in on Network Functions
When programming network functions, changes within a packet tend to have
consequences---side effects which must be accounted for by network programmers
or administrators via arbitrary logic and an innate understanding of
dependencies. Examples of this include updating checksums when a packet's
contents has been modified or adjusting a payload length field of a IPv6 header
if another header is added or updated within a packet. While static-typing
captures interface specifications and how packet contents should behave, it
does not enforce precise invariants around runtime dependencies like the
examples above. Instead, during the design phase of network functions,
programmers should be given an easier way to specify checks up front, all
without having to account for and keep track of these consequences at each and
every step during the development cycle. In keeping with this view, we present
a unique approach for adding and generating both static checks and dynamic
contracts for specifying and checking packet processing operations. We develop
our technique within an existing framework called NetBricks and demonstrate how
our approach simplifies and checks common dependent packet and header
processing logic that other systems take for granted, all without adding much
overhead during development.Comment: ANRW 2019 ~ https://irtf.org/anrw/2019/program.htm
This is not the End: Rethinking Serverless Function Termination
Elastic scaling is one of the central benefits provided by serverless
platforms, and requires that they scale resource up and down in response to
changing workloads. Serverless platforms scale-down resources by terminating
previously launched instances (which are containers or processes). The
serverless programming model ensures that terminating instances is safe
assuming all application code running on the instance has either completed or
timed out. Safety thus depends on the serverless platform's correctly
determining that application processing is complete.
In this paper, we start with the observation that current serverless
platforms do not account for pending asynchronous I/O operations when
determining whether application processing is complete. These platforms are
thus unsafe when executing programs that use asynchronous I/O, and incorrectly
deciding that application processing has terminated can result in data
inconsistency when these platforms are used. We show that the reason for this
problem is that current serverless semantics couple termination and response
generation in serverless applications. We address this problem by proposing an
extension to current semantics that decouples response generation and
termination, and demonstrate the efficacy and benefits of our proposal by
extending OpenWhisk, an open source serverless platform
Recursive SDN for Carrier Networks
Control planes for global carrier networks should be programmable (so that
new functionality can be easily introduced) and scalable (so they can handle
the numerical scale and geographic scope of these networks). Neither
traditional control planes nor new SDN-based control planes meet both of these
goals. In this paper, we propose a framework for recursive routing computations
that combines the best of SDN (programmability) and traditional networks
(scalability through hierarchy) to achieve these two desired properties.
Through simulation on graphs of up to 10,000 nodes, we evaluate our design's
ability to support a variety of routing and traffic engineering solutions,
while incorporating a fast failure recovery mechanism
Application-Defined Receive Side Dispatching on the NIC
Recently, some application (L7) processing has been moved to the network
stack (including proxies) as a way to provide a common and application-agnostic
interface for security policies, simplify service management, etc. This paper
looks at whether L7 network functionality can be offloaded to SmartNICs to
improve performance and reduce overheads. We investigate this question by
examining how to offload to FPGA NICs the task of L7 dispatch: determining
which application process must handle a particular application request. We find
that existing protocols, e.g., gRPC on TCP or QUIC, are a hindrance for
offloading because the data required to make L7 dispatch decisions can be
spread out over many packets, requiring the NIC to buffer and parse a large
number of packets to reconstruct L7 data. This paper presents QingNiao-an
approach that co-designs application libraries, network protocols, and
hardware-to make L7 dispatch feasible under NIC memory constraints. We
prototype QingNiao on a 100Gbps FPGA NIC. Experiments with real-world
applications show that QingNiao supports a variety of dispatch rules and
achieves 7.5x to 8x throughput compared to state-of-the-art software L7
dispatcher. We have open-sourced QingNiao at [1]
New Directions for Network Verification
Network verification has recently gained popularity in the programming languages and verification community. Much of the recent work in this area has focused on verifying the behavior of simple networks, whose actions are dictated by static, immutable rules configured ahead of time. However, in reality, modern networks contain a variety of middleboxes, whose behavior is affected both by their configuration and by mutable state updated in response to packets received by them. In this position paper we critically review recent progress on network verification, propose some next steps towards a more complete form of network verification, dispel some myths about networks, provide a more formal description of our approach, and end with a discussion of the formal questions posed to this community by the network verification agenda