Using the IPv4 Code Option
Contents
Introduction
An SPP is a PlanetLab node that combines the high-performance and programmability of Network Processors (NPs) with the programmability of general-purpose processors (GPEs). The Hello GPE World Tutorial page described how to use a GPE. This page describes the SPP's fastpath (NP) features using the IPv4 meta-net as an example. Those features include:
- Bandwidth, queue, filter and memory resources
- Logical interfaces (meta-interfaces) within each physical interface
- Packet scheduling queues and their binding to meta-interfaces
- Filters for forwarding packets to queues
Like any PlanetLab node, the SPP runs a server on each GPE that allows a user to allocate a subset of a node's resources called a slice. Although an SPP user can prototype a new router by writing a socket program for the GPE, the SPP's high performance can only be tapped by using a SPP's NP. That is, use a fastpath-slowpath packet processing paradigm where the fastpath uses NPs to process data packets at high speed while the slowpath uses GPEs to handle control and exception packets. The SPP's IPv4 code option is an example of this fastpath-slowpath paradigm.
This page describes a simple IPv4 meta-net and in doing so, illustrates the fastpath-slowpath paradigm that would be in any high-speed implementation. Configuring the SPP so that it will process IPv4 packets using the IPv4 code option involves these steps:
- Allocate (and configure) a fastpath (FP)
- Create one or more meta-interfaces (MIs)
- Create and configure packet queues, and bind each queue to an MI
- Install filters to direct incoming packets to packet queues
A fastpath creation request specifies your desire for SPP resources such as interface bandwidths, queues, filters and memory. Once you are granted those resources, you define meta-interfaces within the fastpath and structure meta-interfaces and resources for packet forwarding.
The SPP Fastpath
A network of nodes containing SPPs is formed by connecting the nodes with UDP tunnels. This network forms a substrate-net which can carry packets from one or more meta-nets. The nodes can be SPPs, hosts (PlanetLab and non-PlanetLab), or any packet processors that support this paradigm. A UDP tunnel has two endpoints, each defined by a (IP address, UDP port) pair. Note that this address-port pair is from the addressing domain of the substrate-net. Also, note that an SPP node:
- Has multiple physical interfaces, each with an IP address.
- Can support concurrent traffic from multiple SPP slices (users) at each interface.
A packet that travels through this network of SPPs has an outer (substrate-net) header, an inner (meta-net) header and a payload (packet content); i.e., a meta-net packet is encapsulated in a substrate-net IP/UDP packet. If an SPP has been configured to process the packet using the fastpath, the packet is sent to the NP where the substrate header is removed to expose the meta-net packet. The NP processes the meta-net packet and encapsulates the meta-net packet in an IP/UDP packet before forwarding the packet out of one of its interfaces. In the case of an IPv4 meta-net, an IPv4 packet is encapsulated in another IPv4 packet.
Since the primary function of a router is to forward incoming packets to the next destination (or next hop), a router has to have enough interfaces to accept packets from its neighboring nodes and forward them to the next node. A meta-interface (MI) is a logical interface that is bound to an endpoint, an (IP address, UDP port) pair. The IP address is the address of a physical interface, and the UDP port number is chosen to distinguish the user's traffic from other traffic that shares the same physical interface.
The diagram (right) shows some of the paths that a packet from H1 can take through the FP of the R1 router. For simplicity, the diagram doesn't show resources used by packets from other nodes. The diagram shows these FP features:
- There are five meta-interfaces labeled m0-m4.
- The blocks labeled f19, f6, f23, f0 and f1 are filters that direct meta-net packets to queues q48 q9, q3 and q6. Queues q10, q11 and q0 are not used by packets coming from H1).
- More than one queue (e.g., q9, q10, q11) can be bound to one meta-interface.
A complete diagram would show other features:
- The GPE can inject packets into the FP.
- The complete set of filters form the router's forwarding table.
- Exception packets (e.g., bad meta-net header) are sent to the GPE for further processing.
- Traffic through queues can be monitored using stats indices which in turn can be displayed.
This page shows how to:
- Reserve FP resources and then create a FP for the IPv4 code option.
- Create FP endpoints (meta-interfaces (MIs)) with bandwidth guarantees.
- Create and configure queues with drop thresholds and bandwidth guarantees.
- Bind queues to MIs.
- Install IPv4 filters.
Utilities and Daemons
We will use several utilities and daemons:
- scfg (slice configuration)
- Used to get SPP information, reserve resources, configure queues and allocate/free resources
- ip_fpc (IPv4 filter configuration)
- Used to create IPv4 filters
- ip_fpd (IPv4 daemon)
- Used to create an IPv4 fastpath and process IPv4 local-delivery and exception traffic
- sliced (slice statistics daemon)
- Used to process statistics monitoring requests
The executables are in the directory /usr/local/bin/ on each SPP slice.
Example
>>>>> HERE <<<<<
- overview of Ex1
- 1 SPP
- substrate-net, meta-net relations
- only ping traffic (local and remote)
Preparation
XXXXX getting files, etc
Setup the SPP
XXXXX setup script setupFP1.sh
- MIs
- Implicit MI 0 for LD and EX
- 1 for each FP EP plus MI 0 (LD, EX)
- Filters
- direct incoming packet to queue
- For LD: "--txdaddr 0 --txdport 0 --qid 0"
- Queues
- each queue is bound to an MI
- each MI can have 1 or more queues
- q$N for EX and q${N-1} for LD where $N is #queues
- pkt scheduling: weighted fair queueing
Send Traffic
XXXXX
Teardown the SPP
XXXXX teardown script teardownFP1.sh
Example 2
XXXXX
- simplest complete example
- all traffic
- sliced
