448 research outputs found
Packet Transactions: High-level Programming for Line-Rate Switches
Many algorithms for congestion control, scheduling, network measurement,
active queue management, security, and load balancing require custom processing
of packets as they traverse the data plane of a network switch. To run at line
rate, these data-plane algorithms must be in hardware. With today's switch
hardware, algorithms cannot be changed, nor new algorithms installed, after a
switch has been built.
This paper shows how to program data-plane algorithms in a high-level
language and compile those programs into low-level microcode that can run on
emerging programmable line-rate switching chipsets. The key challenge is that
these algorithms create and modify algorithmic state. The key idea to achieve
line-rate programmability for stateful algorithms is the notion of a packet
transaction : a sequential code block that is atomic and isolated from other
such code blocks. We have developed this idea in Domino, a C-like imperative
language to express data-plane algorithms. We show with many examples that
Domino provides a convenient and natural way to express sophisticated
data-plane algorithms, and show that these algorithms can be run at line rate
with modest estimated die-area overhead.Comment: 16 page
EJ-FAT Joint ESnet JLab FPGA Accelerated Transport Load Balancer
To increase the science rate for high data rates/volumes, Thomas Jefferson
National Accelerator Facility (JLab) has partnered with Energy Sciences Network
(ESnet) to define an edge to data center traffic shaping / steering transport
capability featuring data event-aware network shaping and forwarding. The
keystone of this ESnet JLab FPGA Accelerated Transport (EJFAT) is the joint
development of a dynamic compute work Load Balancer (LB) of UDP streamed data.
The LB is a suite consisting of a Field Programmable Gate Array (FPGA)
executing the dynamically configurable, low fixed latency LB data plane
featuring real-time packet redirection at high throughput, and a control plane
running on the FPGA host computer that monitors network and compute farm
telemetry in order to make dynamic decisions for destination compute host
redirection / load balancing.Comment: Published at INDIS workshop at Supercomm 202
A Survey on Data Plane Programming with P4: Fundamentals, Advances, and Applied Research
With traditional networking, users can configure control plane protocols to
match the specific network configuration, but without the ability to
fundamentally change the underlying algorithms. With SDN, the users may provide
their own control plane, that can control network devices through their data
plane APIs. Programmable data planes allow users to define their own data plane
algorithms for network devices including appropriate data plane APIs which may
be leveraged by user-defined SDN control. Thus, programmable data planes and
SDN offer great flexibility for network customization, be it for specialized,
commercial appliances, e.g., in 5G or data center networks, or for rapid
prototyping in industrial and academic research. Programming
protocol-independent packet processors (P4) has emerged as the currently most
widespread abstraction, programming language, and concept for data plane
programming. It is developed and standardized by an open community and it is
supported by various software and hardware platforms. In this paper, we survey
the literature from 2015 to 2020 on data plane programming with P4. Our survey
covers 497 references of which 367 are scientific publications. We organize our
work into two parts. In the first part, we give an overview of data plane
programming models, the programming language, architectures, compilers,
targets, and data plane APIs. We also consider research efforts to advance P4
technology. In the second part, we analyze a large body of literature
considering P4-based applied research. We categorize 241 research papers into
different application domains, summarize their contributions, and extract
prototypes, target platforms, and source code availability.Comment: Submitted to IEEE Communications Surveys and Tutorials (COMS) on
2021-01-2
Traffic Optimization in Data Center and Software-Defined Programmable Networks
L'abstract è presente nell'allegato / the abstract is in the attachmen
SPIDER: Fault Resilient SDN Pipeline with Recovery Delay Guarantees
When dealing with node or link failures in Software Defined Networking (SDN),
the network capability to establish an alternative path depends on controller
reachability and on the round trip times (RTTs) between controller and involved
switches. Moreover, current SDN data plane abstractions for failure detection
(e.g. OpenFlow "Fast-failover") do not allow programmers to tweak switches'
detection mechanism, thus leaving SDN operators still relying on proprietary
management interfaces (when available) to achieve guaranteed detection and
recovery delays. We propose SPIDER, an OpenFlow-like pipeline design that
provides i) a detection mechanism based on switches' periodic link probing and
ii) fast reroute of traffic flows even in case of distant failures, regardless
of controller availability. SPIDER can be implemented using stateful data plane
abstractions such as OpenState or Open vSwitch, and it offers guaranteed short
(i.e. ms) failure detection and recovery delays, with a configurable trade off
between overhead and failover responsiveness. We present here the SPIDER
pipeline design, behavioral model, and analysis on flow tables' memory impact.
We also implemented and experimentally validated SPIDER using OpenState (an
OpenFlow 1.3 extension for stateful packet processing), showing numerical
results on its performance in terms of recovery latency and packet losses.Comment: 8 page
LOcAl DEcisions on Replicated States (LOADER) in programmable data planes: programming abstraction and experimental evaluation
Programmable data planes recently emerged as a prominent innovation in
Software Defined Networking (SDN), by permitting support of stateful flow
processing functions over hardware network switches specifically designed for
network processing. Unlike early SDN solutions such as OpenFlow, modern
stateful data planes permit to keep (and dynamically update) local per-flow
states inside network switches, thus dramatically improving reactiveness of
network applications to state changes. Still, also in stateful data planes, the
control and update of non-local states is assumed to be completely delegated to
a centralized controller and thus accessed only at the price of extra delay.
Our LOADER proposal aims at contrasting the apparent dichotomy between local
states and global states. We do so by introducing a new possibility: permit to
take localized (in-switch) decisions not only on local states but also on
replicated global states, thus providing support for network-wide applications
without incurring the drawbacks of classical approaches. To this purpose, i) we
provide high-level programming abstractions devised to define the states and
the update logic of a generic network-wide application, and ii) we detail the
underlying low level state management and replication mechanisms. We then show
LOADER's independence of the stateful data plane technology employed, by
implementing it over two distinct stateful data planes (P4 switches and OPP -
Open Packet Processor - switches), and by experimentally validating both
implementations in an emulated testbed using a simple distributed
Deny-of-Service (DoS) detection application
- …