DPDK Summit 2015 - Sprint - Arun Rajagopal

©2015 Sprint. This information is subject to Sprint policies regarding use and is the property of Sprint and/or its relevant affiliates and may contain restricted,
confidential or privileged materials intended for the sole use of the intended recipient. Any review, use, distribution or disclosure is prohibited without authorization.
#moveforward
Design Considerations for a High-Performing
Virtualized LTE Core Infrastructure
Arun Rajagopal
Sprint CTO Office
Sameh Gobriel
Intel Labs

Current EPC Network Infrastructure
#moveforward

Carrier Business Problems
Rigid capacity models lead to inefficient utilization of
network resources
Capacity added when one dimension exhausts (e.g., signaling vs. bearer capacity on
SBC)
Difficult to align service revenue with costs (e.g., low volume M2M)
No means to re-use stranded capacity on platforms
Long time-to-market intervals for new products/services
Long service development processes with limited service agility
Limited fast fail opportunities and platform re-usability
Rapid service scaling is a challenge
Adding new capacity to existing services takes time
Managing scale by adding additional hardware and using load balancing mechanisms is
complex
More nodes/elements to manage as the function scales
Lack of
Service
Agility
Rapid and just-in-
time service scaling
Rigid
network
build models
#moveforward

©2014 Sprint This information is subject to Sprint policies regarding use and is the property of Sprint and/or its relevant affiliates and may contain
restricted, confidential or privileged materials intended for the sole use of the intended recipient Any review, use, distribution or disclosure is
prohibited without authorization
The Case for NFV
Simplifies Network
Architecture
• Common hardware
• Independent scaling of components
• Standard and repeatable
configurations
Simplifies Network
Operations
• Just-in-time allocation
• Automated deployment
• Automated capacity add
• Agile, high velocity service creation
environment
Creates New Revenue
Opportunities
• Combine Mobility and call control
with cloud technologies
• Monetize network based on service
value
Lower Capex Lower Opex Higher Revenue
#moveforward

#moveforward
From Purpose Built ASICs to General Purpose IA
1850R
PROLIANT
1850R
PROLIANT
1850R
PROLIANT
1850R
PROLIANT
SGW
PDN
GW
MME
PCRF
vEPC
SGW
PDN
GW
vEPC
SGW
PDN
GW
vEPC
SGW
PDN
GW
vEPC
Internet
eNode B
How to build a scalable EPC cluster on
IA servers?
 Fully programmable control &
data planes
 Incrementally scalable as needed
by adding nodes to the cluster
 S/P GW ported as DPDK Apps on
top of IA Cluster.
 Leverages multi-core/socket,
DDIO, SSE instructions, ..etc.
A first step towards a flexible network
infrastructure

Flow Table Size and Packet Classification Bottleneck
• EPC SGW session table size grow significantly (millions of entries) with the number of
subscribers/bearers/flows.
• Flow lookup and Packet classification is common for many VNFs.
• Distributed flow table as a single entity to control/management plane.
1850R
PROLIANT
1850R
PROLIANT
1850R
PROLIANT
1850R
PROLIANT
SGW
PDN
GW
MME
PCRF
vEPC
SGW
PDN
GW
vEPC
SGW
PDN
GW
vEPC
SGW
PDN
GW
vEPC
Internet
eNode B
(1) Single Node
Optimization
(2) Cluster Level
Optimization
#moveforward

Flow Lookup & Classification Bottleneck for NFV
• Flow lookup and Classification a common operation for many network functions.
• NFV workload will typically have large flow table sizes
M1[1]
Q[1] Q[2] Q[3]
M2[1]
M3[1]
M1[2] M1[3]
M2[2] M2[3]
M3[2] M3[3]
search lines
match lines
search word
encoder
• ASICs, NPUs uses TCAM to address this bottleneck.
• TCAMs sizes are very limited
#moveforward

Flow Lookup & Classification Bottleneck for NFV
Cuckoo Hashing
IP A IP H
IP P
IP J IP B
IP Q
IP D IP W
Traditional Hashing
IP Y
IP Z
IP X
1
2
3
H1 H2
Traditional J-hash library:
• relies on a “sparse” hash table
implementation
• Simple exact match implementation
• Significant performance degradation with
increased table sizes.
Cuckoo Hashing – Better Scalability:
• Denser tables fit in cache.
• Can scale to millions of entries.
• Significant throughput improvement
Available for DPDK v2.1
#moveforward

Cuckoo Hashing [Pagh ‘01]
B C
D
F
F
G
E
A
#moveforward

Performance benefits of CH w/ DPDK
Improvement on table efficiency ~40% Throughput increase
Memory bandwidth significantly reduced due to higher cache utilization
Traditional hash
0.00
500.00
1,000.00
1,500.00
2,000.00
2,500.00
3,000.00
10 1M 4M
Memory bandwidth vs. # of entries
rte_hash
Cuckoo
Traditional hash
0.00
2.00
4.00
6.00
8.00
10.00
12.00
14.00
16.00
18.00
1M 2M 4M 8M 16M 32M
Throughput vs. # of entries
rte_hash
Cuckoo
Traditional hash
Single Core Table Insertions per second
0
1
2
3
4
5
6
7
8
9
0% 10% 20% 30% 40% 50% 60% 70% 80%
Inserts/Second
Millions
Table Load
Cuckoo Hash Insert Performance
32M Random
8M Random
2M Random
32M Sequential
15X
#moveforward

Distributed software flow lookup
A C
B
D
Partial FIB
Full Duplication Hash Partitioning Scalable Switch Route
Forward (S2RF)
Nodes store FULL copy of FIB
Pros: Design simplicity, scales
throughput
Cons: FIB does not scale as FIB
capacity does not increase with the
number of nodes in the cluster
Node stores ONLY a portion of the FIB based
on the hash of the keys (destination address,
flow identifier …)
Pros: Design simplicity, near linear scalability
Cons: Latency w/ extra hop, increased
interconnect load and CPU load for IO
bouncing, potential traffic hot spots (w/
elephant flows)
Nodes keep globally-replicated but extremely
compact, and fast, table (Global Partition Table)
mapping keys to lookup nodes
FIB partitioned so lookup node for packet is
also its egress node
Pros: No extra latency and interconnect load,
min resources required
A C
B
D
Full FIB
“Improving Clustered Network Appliances with
Xbricks”, Sigcomm ‘15
A C
B
D
GPT +
Partial FIB
#moveforward

Lookup Table Space Optimization for GPT
Main Idea:
Throw away keys (from cache), Use perfect hashing to avoid collision
For k-bit keys and v-bit values can we use O(v)
instead of O(k + v) bits/entry ?
KEY: k bits VAL: vbits
Ren
Dave
Christian
Dong
Sameh
Online/offline Status
Christian 0
Dong 1
Dave 0
Sameh 1
Ren 1
Ren
Dong
Sameh
Christian
Dave
H(Ren) = 1
H(Dave) = 0
H(Dong) = 1
H(Sameh) = 1
H(Christian) = 0
Ren
Dave
Christian
Dong
Sameh
Online/offline Status
#moveforward

Store m for this group of keys
Target
Value
H1(x) H2(x) … Hm(x)
key1 0 0 1 0
key2 1 0 1 1
…
key16 0 0 0 0
GPT: From One Group to Many Groups
All keys
group1 group2 group3 group4
H376
Store hash function index for each
group of keys
H97 H62H7
#moveforward

S2RF Code Snippet
void NxtHopTableUpdate(tNxtHopTable *table, U32 key, U8 value)
{
U32 h = CheapHash(key);
U32 chunkId = h % table->numChunks;
U32 binId = (h / table->numChunks) % NXTHOPTABLE_CHUNK_NUM_BINS;
U8 choice_chunk = table->chunks[chunkId].choiceList[binId / 4];
int i, offset = (binId & 0x3) * 2;
U8 choice = (U8)((choice_chunk >> offset) & 0x3);
U32 groupId = binPerm[choice][binId];
for (i = 0; i < table->chunkRuleList[chunkId].groupSize[groupId]; ++i)
if (table->chunkRuleList[chunkId].groupRuleList[groupId][i].ip == key)
{
table->chunkRuleList[chunkId].groupRuleList[groupId][i].Id = value;
break;
}
int ret = SearchHash(table, table->chunkRuleList[chunkId].groupSize[groupId],
table->chunkRuleList[chunkId].groupRuleList[groupId])}
GPT Update
void NxtHopTableLookupMulti(tNxtHopTable *table, int numKeys, U32 *keyList, U8
*valueList) {
…
for (i = 0; i < numKeys; i++) {
U32 h = CheapHash(keyList[i]);
chunkIdList[i] = h % table->numChunks;
binIdList[i] = (h / table->numChunks) % NXTHOPTABLE_CHUNK_NUM_BINS;
rte_prefetch0(&table->chunks[chunkIdList[i]].choiceList[binIdList[i]); }
choiceList[i] = GetChoice(table, chunkIdList[i], binIdList[i]);
groupIdList[i] = BinToGroup(binIdList[i], choiceList[i]);
rte_prefetch0(&table->chunks[chunkIdList[i]].groups[groupIdList[i]]); }
hashValA[i] = NXTHOPTABLE_HASHFUNCA(keyList[i]);
hashValB[i] = NXTHOPTABLE_HASHFUNCB(keyList[i]);
valueList[i] = 0;
for (bit = 0; bit < NXTHOPTABLE_VALUE_SIZE_MAX; bit++) {
U16 hashFuncIdx;
U16 lookupTbl;
GetGroup(
&table->chunks[chunkIdList[i]].groups[groupIdList[i]],
NXTHOPTABLE_VALUE_SIZE_MAX - bit - 1,
&hashFuncIdx, &lookupTbl)
valueList[i] = LookupBit(table, hashFuncIdx, lookupTbl);
}
Update  finding a new hash function that
satisfies the new value
GPT Lookup
Lookup  hash computation knowing the
group hash index
Find group_id using
cheap hash
Using hash index do
lookup
#moveforward

S2RF Performance Quantification
• SNB @ 2.2Ghz, 20 MB LLC
• 4-Node Cluster, 16*10 Gbps Niantic vector driver/DPDK
• IPv4 random traffic, i.e. 1/N on local node, ¾ on remote node
Single Core Table Insertions per second
Scales Linearly with number of cores
~35% Better Throughput
0
1
2
3
4
5
6
7
8
9
0% 10% 20% 30% 40% 50% 60% 70%
Inserts/Second
Millions
Table Load
Global Table Insert Performance
32M Sequential
8M Sequential
2M Sequential
Full
Duplication
#moveforward

Best Practices for Efficient Packet processing
Avoiding serialization in the packet-processing pipeline, including serializing events
such as locks, special instructions such as CLFLUSH, and large critical sections
Accessing data from the cache where possible by making use of prefetch
instructions and observing best practices in design of the software pipeline
Designing data structures to be cache-aligned and avoiding occurrences of data
being spread across two cache lines, partial writes, and contention between write
and read operations
Maintaining affinity between software threads and hardware threads, as well as
isolating software threads from one another with regard to scheduling relative to
hardware threads
Breaking down user-plane functionality so that it can be implemented with a
combination of RTC (Run to Completion) and pipeline methods
Use of pre-tuned open source optimized software components like DPDK
#moveforward

Summary
Lack of
Service Agility
Rapid and just-in-
time service scaling
Rigid network
build models
• Scalable Switch Route Forward
(S2RF) helps address some of the
scaling challenges in carrier networks
 Scales linearly the number of ports and
flow classification size with the number of
nodes in a cluster
 Uses DPDK and IA optimizations for
efficient packet processing and I/O
performance
#moveforward

Questions
#moveforward

DPDK Summit 2015 - Sprint - Arun Rajagopal

Recommended

More Related Content

What's hot (20)

Viewers also liked (16)

Similar to DPDK Summit 2015 - Sprint - Arun Rajagopal (20)

More from Jim St. Leger (6)

Recently uploaded (20)

DPDK Summit 2015 - Sprint - Arun Rajagopal