Linkmeup v076(2019-06).2

Copyright © 2019 - Barefoot Networks. Public Presentation
P4? That's Easy!
March 9, 2019
Vladimir Gurevich

Agenda
• How high-speed devices work
• P4 by example
• What's next
2

Bringing Data Plane back in the NOS
3
Management Plane
Configuration CLI/GUI/SNMP...
Control Plane
Protocol Stacks
ARP
??
STPIS-IS
PIM-SM
BGP
???
Data Plane
That’s how
packets should
be processed!
Requirements
That’s how I
want to build my
network!

Why is it important?
C
Control and Customization. Make the device behave exactly as you want
R
Robustness and Reliability. Reduce the risk by removing unused features
E
Energy Efficiency. Use only what you need
A
Agility. Add features as you go
T
Telemetry and Tracing. Be able to see inside the Data Plane
E
Exclusivity and Differentiation. No need to share your IP with the chip vendor
4

Programmable vs. Fixed Pipelined Architecture
Buffer
FixedParser
IPv4
Address
Table
IPv4
Logic
ACL Logic
ACL
TCAM
MPLS
Tag Table
MPLS
Logic
Ethernet
MAC
Address
Table
Ethernet
Logic
Fixed Pipeline: features and table-sizes are baked in at design time
Buffer
ProgrammableParser
M A
M
M
M
M
M
A
A
A
A
A
M A
M
M
M
M
M
A
A
A
A
A
M A
M
M
M
M
M
A
A
A
A
A
…
M A
M
M
M
M
M
A
A
A
A
A
Programmable Pipeline: all stages identical, customer-defined match-action logic
You declare which
headers are recognized
You declare what tables are needed and how packets are processed

PISA: Protocol-Independent Switch Architecture
6
Match+Action
Stage (Unit)
Memory ALU
Programmable
Parser
Programmable
Deparser
Programmable Match-Action Pipeline
Programmer declares the
headers that should be
recognized and their order
in the packet
Programmer defines the
tables and the exact
processing algorithm
Programmer declares
how the output packet will
look on the wire
User-defined Headers and
Metadata

PISA in Action
• Packet is parsed into individual headers
(parsed representation)
• Headers and intermediate results can be
used for matching and actions
• Headers can be modified, added or
removed
• Packet is deparsed (serialized)
7
• Feed-forward architecture
• Stage-local resources
• One packet per clock
• Constant processing latency
• Longer pipe – more packets processed in
parallel
• Multiple simultaneous lookups are possible
Match+Action
Stage (Unit)
Programmable
Parser
Programmable
Deparser
Programmable Match-Action Pipeline

Building a Real Switch
Programmable components Fixed-Function Components
8
• Ingress and Egress Pipeline
◦Parser
◦Match-Action Pipeline
◦Deparser
• Packet I/O (MAC/SerDes/DMA)
• Packet Replication Engine
• Traffic Manager
Ingress pipeline Egress pipelineIntrinsic Metadata
User-defined Headers
and Metadata
Packet
Replication
Engine
&
Traffic
Manager
PacketIngress
PacketEgress
Packet data in
Packet data out

P414 Program Sections
9
parser parse_ethernet {
extract(ethernet);
return select(ethernet.ethertype) {
0x8100 : parse_vlan_tag;
0x0800 : parse_ipv4;
0x8847 : parse_mpls;
default: ingress;
}
table port_table { … }
control ingress {
apply(port_table);
if (l2_meta.vlan_tags == 0) {
process_assign_vlan();
}
}
header_type ethernet_t { … }
header_type l2_metadata_t { … }
header ethernet_t ethernet;
header vlan_tag_t vlan_tag[2];
metadata l2_metadata_t l2_meta;
Headers and Metadata
Parser
Tables, Actions, Controls and other objects
PRE/
TM
PacketInput
PacketOutput

/* -*- P4_14 -*- */
/* Standard includes for Tofino */
#include <tofino/constants.p4>
#include <tofino/primitives.p4>
#include <tofino/intrinsic_metadata.p4>
/******************* H E A D E R T Y P E S *************************/
header_type ethernet_t {
fields {
dstAddr : 48;
srcAddr : 48;
etherType : 16;
}
}
/*********************** M E T A D A T A *****************************/
/*********************** P A R S E R *********************************/
parser start {
extract(ethernet);
return ingress;
}
/************** I N G R E S S P R O C E S S I N G *****************/
control ingress {
}
/**************** E G R E S S P R O C E S S I N G *****************/
control egress {
}
P414 Program Template for Tofino
10
• P4 uses C preprocessor
◦ Include Tofino-specific definitions
◦ Use it to structure your programs
• C and C++style comments are supported
◦ Use first line to choose Emacs mode
• P4 objects can be defined in any order
◦ There is no requirement to declare before using
What does this
program do?

Defining the Header Types
11
header_type ethernet_t {
fields {
dstAddr : 48;
srcAddr : 48;
etherType : 16;
}
}
header_type vlan_tag_t {
fields {
pcp : 3;
cfi : 1;
vid : 12;
etherType : 16;
}
}
header_type ipv4_t {
fields {
version : 4;
ihl : 4;
tos : 8;
totalLen : 16;
identification : 16;
flags : 3;
fragOffset : 13;
ttl : 8;
protocol : 8;
hdrChecksum : 16;
srcAddr : 32;
dstAddr : 32;
}
}

header vlan_tag_t vlan_tag;
header ipv4_t ipv4;
parser start {
extract(ethernet);
return select(ethernet.etherType) {
0x8100, 0x9100 : parse_vlan_tag;
default : ingress;
}
}
parser parse_vlan_tag {
extract(vlan_tag);
return select(vlan_tag.etherType) {
default : ingress;
}
}
parser parse_ipv4 {
extract(ipv4);
return ingress;
}
Defining the Parser
12
• Define the header instances
◦ That’s the headers the program will process
• Define parser states
◦ Parsing starts with the “start” state
• Inside the states
◦ Extract headers
◦ Transition to other states
■ Both exact and ternary matching are supported

action send(port) {
modify_field(ig_intr_md_for_tm.ucast_egress_port, port);
}
action discard() {
modify_field(ig_intr_md_for_tm.drop_ctl, 1); /* drop() */
}
table ipv4_host {
reads {
ipv4.dstAddr : exact;
}
actions {
send;
discard;
}
size : 131072;
}
table ipv4_lpm {
reads {
ipv4.dstAddr : lpm;
}
actions {
send;
discard;
}
default_action: send(64);
size : 12288;
}
Defining Tables and Actions
13
• Actions consist of P4 primitive sequences
• Actions can have parameters (action data)
• Intrinsic metadata controls the device
• Tables specify
◦ The key (match fields and match type)
◦ List of possible actions
◦ Other attributes (default action, size, etc.)
■ Note: Attribute order is fixed in P414 grammar
Architecture-specific
Intrinsic Metadata
Intrinsic Metadata
ipv4.dstAddr action data
192.168.1.1 send port=1
192.168.1.2 send port=2
192.168.1.3 discard ---
Not Set
ipv4.dstAddr / prefix action data
192.168.1.0 / 24 send port=1
10.0.16.0 / 22 send port=5
192.168.0.0 / 16 discard --
send port=64 (CPU)
ipv4_host
ipv4_lpm
To be filled by the
control plane!

/* Ingress Pipeline Processing */
control ingress {
if (valid(ipv4)) {
apply(ipv4_host) {
miss {
apply(ipv4_lpm);
}
}
}
}
/* Egress Pipeline Processing */
control egress {
}
Defining the Processing Algorithm
14
• Direct Acyclic Graph processing (no loops)
• apply() – perform match-action in a table
• apply() {} – use match results to determine
further processing
◦ hit/miss clause
◦ selected action clause
• Conditional statements
◦ Comparison operations (==, !=, >, <, >=, <=)
◦ Logical operations (not, and, or)
◦ Header validity checks
• Make sure the program operates on valid
headers!

Add counters
15
• Direct counters extend table entries
• Counting is done automatically
ipv4.dstAddr action data Packets/Bytes
192.168.1.1 send port=1 xxx / yyy
192.168.1.2 send port=2 zzz / ww
192.168.1.3 discard ---
Not Set
ipv4.dstAddr / prefix action data Packets/Bytes
192.168.1.0 / 24 send port=1 xxx / yyy
10.0.16.0 / 22 send port=5
192.168.0.0 / 16 discard --
send port=64 (CPU)
ipv4_host
ipv4_lpm
/* Just add this code... */
counter ipv4_host_counter {
type: packets_and_bytes;
direct: ipv4_host;
}
counter ipv4_lpm_counter {
type: packets_and_bytes;
direct: ipv4_lpm;
}

Add Port-Based VRF
16
Different lookup domains for different
customers
VRF ipv4.dstAddr action data Packets/Bytes
0 192.168.1.1 send port=1 xxx / yyy
1 192.168.1.1 send port=7 zzz / ww
1 192.168.1.3 discard ---
Not Set
VRF ipv4.dstAddr / prefix action data Packets/Bytes
0 192.168.1.0 / 24 send port=1 xxx / yyy
1 192.168.1.0 / 24 send port=5
2 192.168.0.0 / 16 discard --
send port=64 (CPU)
ipv4_host
ipv4_lpm
ingress_port action data
0 set_vrf vrf_id=2
12 set_vrf vrf_id=1
4 set_vrf vrf_id=2
Not Set
vrf
/* New Code */
header_type l3_meta_t {
fields {
vrf_id : 8;
}
}
metadata l3_meta_t l3_meta;
action set_vrf(vrf) {
modify_field(l3_meta.vrf_id, vrf);
}
table vrf {
reads { ig_intr_md.ingress_port : exact; }
actions { set_vrf; }
}
table ipv4_host {
reads {
l3_meta.vrf_id : exact;
ipv4.dstAddr : exact;
}
. . .
}
control ingress {
apply(vrf);
if (valid(ipv4)) {
apply(ipv4_host) { miss { apply(ipv4_lpm); } }
}
}
Intrinsic Metadata

Add Packet Modifications and Checksum Handling
17
action l3_switch(new_mac_da, new_mac_sa, port) {
modify_field(ethernet.dstAddr, new_mac_da);
modify_field(ethernet.srcAddr, new_mac_sa);
add_to_field(ipv4.ttl, -1);
send(port);
}
action nat_tcp(new_src_ip, new_dst_ip,
new_tcp_sport, new_tcp_dport) {
modify_field(ipv4.srcAddr, new_src_ip);
modify_field(ipv4.dstAddr, new_dst_ip);
modify_field(tcp.srcPort, new_tcp_sport);
modify_field(tcp.dstPort, new_tcp_dport);
}
action untag_packet() {
modify_field(ethernet.etherType, vlan_tag.etherType);
remove_header(vlan_tag);
}
field_list ipv4_checksum_list {
ipv4.version;
ipv4.ihl;
ipv4.diffserv;
ipv4.totalLen;
ipv4.identification;
ipv4.flags;
ipv4.fragOffset;
ipv4.ttl;
ipv4.protocol;
ipv4.srcAddr;
ipv4.dstAddr;
}
field_list_calculation ipv4_checksum {
input { ipv4_checksum_list; }
algorithm : csum16;
output_width : 16;
}
calculated_field ipv4.hdrChecksum {
verify ipv4_checksum;
update ipv4_checksum;
}

counter packet_size_stats {
type : packets;
direct : packet_size_hist;
min_width : 32;
}
action nop() { }
table packet_size_hist {
reads {
eg_intr_md.pkt_length : range;
}
actions {
nop;
}
}
control egress {
apply(packet_size_hist);
}
Example: Building a Histogram of Packet Sizes
18
• Problem:
◦ Calculate a histogram of different packet sizes
that passed through the switch
• Solution:
◦ Use range matching on packet length
■ Only available in the egress pipeline
range is a standard match
type in P4
0
50
100
150
200
250
300
0-63
64-127
128-255
256-511
512-1023
1024-…
1537…
Packets
64..127
128..255
256..511
0..63
1024..1536
512..1023
1537..16384
Match Fields
nop
nop
nop
nop
nop
nop
nop
Action
packet counts
counter A
counter Z
Counter
table packet_size_hist counter packet_size_stats
Architecture-specific Intrinsic
Metadata

Ethernet Header
EtherType = 0xDEAD
+----------------+----------------+
| Box Number (0..65536) |
+----------------+----------------+
| Operation: 0 – drop, 1 – pickup |
+----------------+----------------+
| Data Destination (port #) |
+----------------+----------------+
| |
+- TOP SECRET -+- DATA (32b) -+
| |
+----------------+----------------+
header_type dead_drop_t {
fields {
box_num : 16;
box_op : 16;
data_dest : 16;
box_data : 32;
}
}
header dead_drop_t dead_drop;
Dead-Drop Protocol
19
• Two operations:
◦ Drop data (with further delivery instructions)
◦ Pickup data
• Tamper-proof
◦ Cannot pick data more than once

Parsing Dead-Drop Protocol
P4 Scapy
20
header_type dead_drop_t {
fields {
box_num : 16;
box_op : 16;
data_dest : 16;
box_data : 32;
}
}
header dead_drop_t dead_drop;
parser parse_ethernet {
extract(ethernet);
select(ethernet.etherType) {
...
0xDEAD : parse_dead_drop;
default: ingress;
}
}
parser parse_dead_drop {
extract(dead_drop);
return ingress;
}
class DeadDrop(Packet):
fields_desc = [ BitField("box_num", 0, 16),
BitField("box_op", 0, 16),
BitField("data_dest", 511, 16),
BitField("box_data", 0xDEADBABE, 32)
]
name = “Spy Dead-Drop Protocol”
bind_layers(Ether, DeadDrop, type=0xDEAD)
sendp(Ether()/DeadDrop(box_num=5, box_op=0,
data_dest=3, box_data=0x12345678),
iface="veth1")
• When DeadDrop() follows Ether(), set Ether.type=0xDEAD
• When Ether.type==0xDEAD, next header is DeadDrop()
In Scaly, each field
has a default value

Dead Drop Implementation (P414 specification)
Data Store (Registers) Actions and Tables
21
register dead_drop_data {
width : 32;
instance_count : 65536;
}
register dead_drop_dest {
width : 16;
instance_count : 65536;
}
action drop_message() {
register_write(dead_drop_data, dead_drop.box_num, dead_drop.box_data);
register_write(dead_drop_dest, dead_drop.box_num, dead_drop.data_dest);
modify_field(ig_intr_md_for_tm.drop_ctl, 1); /* drop */
exit();
}
action pickup_message() {
register_read(dead_drop.box_data, dead_drop_data, dead_drop.box_num);
register_read(ig_intr_md_for_tm.ucast_egress_port,
dead_drop_dest, dead_drop.box_num);
register_write(dead_drop_dest, dead_drop.box_num, 511 /* drop */);
register_write(dead_drop_data, dead_drop.box_num, 0);
exit();
}
table dead_drop {
reads {
dead_drop.box_op : exact;
}
actions {
drop_message;
pickup_message;
}
size : 2;
}
control ingress {
if (valid(ipv4)) {
apply(ipv4_host) {
. . .
}
if (valid(dead_drop)) {
apply(dead_drop);
}
}

Brief History and Trivia
22
• May 2013: Initial idea and the name “P4”
• July 2014: First paper (SIGCOMM CCR)
• Aug 2014: First P414 Draft Specification (v0.9.8)
• Sep 2014: P414 Specification released (v1.0.0)
• Jan 2015: P414 v1.0.1
• Mar 2015: P414 v1.0.2
• Nov 2016: P414 v1.0.3
• May 2017: P414 v1.0.4
• Apr 2016: P416 – first commits
• Dec 2016: First P416 Draft Specification
• May 2017: P416 Specification released
• . . .
• Official Spelling P4_16 on terminals, P416 in publications

The P4 Language Consortium
• Consortium of academic
and industry members
• Open source, evolving,
domain-specific language
• Permissive Apache license,
code on GitHub today
• Membership is free:
contributions are welcome
• Independent, set up as a
California nonprofit
23

Systems
P4.org Membership
Academia/
Research
Targets
Operators/
End Users
Original P4 Paper Authors:
• Open source, evolving, domain-specific language
• Permissive Apache license, code on GitHub today
• Membership is free: contributions are welcome
• Independent, set up as a California nonprofit
Solutions/
Services

P416 Design Goals
• Logical Evolution of P414
◦ Same basic building blocks and concepts
◦ More expressive and convenient to use
◦ More formally defined semantics
■ Strong Type System
◦ Support for good software engineering practices
• Target-Independence
◦ Support for a variety of targets (ASICs, FPGAs, NICs, software)
■ Language/Architecture separation
■ Flexible data plane model
• Non-goals
◦ New constructs
◦ General-purpose programming
25

To Learn More
• Become a Barefoot Customer or joint FASTER program
• Attend BA-101 (P414) or BA-102 (P416) class
26

Thank you

Linkmeup v076(2019-06).2

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Linkmeup v076(2019-06).2

Similaire à Linkmeup v076(2019-06).2 (20)

Plus de eucariot

Plus de eucariot (20)

Dernier

Dernier (20)

Linkmeup v076(2019-06).2