Institute of Computer and
Communication Network Engineering
OFC/NFOEC, 6-10 March 2011, Los Angeles, CA
Lessons Learned From Implementing a Path
Computation Element (PCE) Emulator
Mohit Chamania, Marek Drogon, Admela Jukan
In this Talk We will..
• Present an overview of the PCE emulator developed
at IDA
• Describe the design motivations and subsequent
implementations for different PCE components
• Outline areas for innovation in developing and
extending the PCE server architecture
2
Outline
• PCE architecture Overview
• PCE Emulator
• PCE Server Implementation
• PCE Client Implementation
• Challenges In Implementation
3
PCE Overview
2
PCC connects
to the PCE andthe
sends
PCE communicates
4
a path
computation
computed
path torequest
the PCC
PCE
3
PCE uses TE information from TED
to compute path request
TED
Database to store Traffic
Engineering information
used by PCE
TED
updated using TE information from
1
Network control/management Plane
Responsible for serving
computation requests
R2
Client on Network
Nodes to send
requests to PCE
R6
PCC
R4
R1
R3
5
R5
Network Node uses computed
path info to being reservation
Three Primary Components
• Path Computation Element (PCE)
• Path Computation Client (PCC)
• Traffic Engineering Database (TED)
5
Outline
• PCE architecture Overview
• PCE Emulator
• PCE Server Implementation
• PCE Client Implementation
• Challenges In Implementation
6
PCE Emulator Overview
Designed as a general purpose PCE with four primary
design goals
– Should be easily extensible to evaluate extensions to the
PCEP protocol and state machine
– Reusable: Require minimal effort to incorporate topological
and network specific path computation features into the PCE
– Scalable: Should have capability to support a large number of
PCEP requests in the network.
– Low Overhead: Should run on typical commercial hardware
7
PCE Emulator Overview
• The implementation of the PCE and the PCC contain
common functions including State machine, network
I/O and PCEP protocol implementations
• Differences include:
– PCE implementing a path computation function
– PCC implementing an client interface to facilitate other
applications to interact with the PCE.
• TED implemented as a separate package using Java
based Graph library
8
Outline
• PCE architecture Overview
• PCE Emulator
• PCE Server Implementation
• PCE Client Implementation
• Challenges In Implementation
9
PCE Server Overview
• Three primary layers
Computation Layer
Session Handler
Network Layer
– Network I/O layer
– Session Handler
– Computation Layer
• Use of layers with standard
Interfaces to facilitate extensibility
• PCE Protocol implemented as a Java
package
• Each layer can be
duplicated/replaced with a different
implementation supporting the
defined inter-layer interfaces.
10
PCEP Package Overview
PCEPMessage
Header
Header
Header
MessageFrame
PCEPObject
Header
Object
PCEPObject
Header
Object
The PCEP Protocol is used for communication between the PCC and the PCE
• Each PCEP message consists of a Message Header and a Message Frame
• The Message Frame consists of multiple PCEP Objects
• Each Object itself consists of an Object header and body
• Message hierarchy duplicated in the package which can be extended to add
new messages/objects
11
PCEP Extensibility
• All PCEP messages and objects use a standard interface which
can be easily extended
• Use a single Factory to generate all PCEP messages (Single
point of logic for ease of implementation)
• Message conformity forced by providing checks on required
objects – additional objects can be inserted easily with
minimal effort
• All inter-layer interfaces only use PCEPMessage types, and are
therefore compatible with new message types
12
Network Layer Overview
• Primary function to facilitate
Network I/O with remote peers
Thread Pool
Computation Handler
• Designed to support large number
of concurrent sessions with low
traffic volumes
Graph Library
Timer
State Machines
Map(Address,Statemachine)
Session Handler
Register With
Session
Handler
PCE Protocol
Map(Address,Socket)
Sockets
In Msg.
In Msg.
In Msg.
New Conn
Socket
Register
new
Connection
Selector
• Use of Asynchronous Network I/O
means that one process handles all
incoming messages / connection
requests
New
Connection
Connection
Registered
Arrives
13
Network Layer Overview
• Primary function to facilitate
Network I/O with remote peers
Thread Pool
Computation Handler
• Designed to support large number
of concurrent sessions with low
traffic volumes
Graph Library
Timer
State Machines
Map(Address,Statemachine)
Session Handler
Address,
PCEPMessage
Address
Byte[]
Register With
Session
Handler
PCE Protocol
Address, Byte[]
Map(Address,Socket)
Sockets
In Msg.
In Msg.
In Msg.
Socket
Register
new
Connection
Selector
New Conn
Get
Socket via
Address
• Use of Asynchronous Network I/O
means that one process handles all
incoming messages / connection
requests
Response
Message
New Message
From
Sent
Session
To
Arrives
Peer
Handler
8
Session Handler Overview
Thread Pool
Computation Handler
Graph Library
State Machine Interface: Timer
//Update state due to incoming message from Network
State Machines
Void updateStateNL(PCEPMessage);
Map(Address,Statemachine)
Session Handler
//Update
state due to message from Computattion layer
Void updateStateCL(PCEPMessage);
//Update state due to a timeout
Void updateState(ID nextState);
PCE Protocol
Map(Address,Socket)
Selector
Sockets
• Governs the processing of
PCEP message based on State
Machine
• All state machine transitions
based on either incoming
messages or timeouts
• State machines implemented
as objects with Session
Handler and Timer initiating
State Changes
In Msg.
In Msg.
In Msg.
New Conn
Socket
9
State Machine Extensibility
• PCEP State Machines may need to be modified to add
additional functions such as AA
• Session Handler can use different State machine
implementations which implement the standard interface
• Different implementations can also be run at the same time e.g.
different state machines for internal and inter-domain
computation requests
• Existing implementation provided with additional (empty)
function triggered at every state transition
void stateTransition (ID currState, ID nextState)
10
Session Handler Overview
Thread Pool
Computation Handler
Graph Library
PCEP
Request
Reset Timeout Event
Timer
State Machines
Map(Address,Statemachine)
Session Handler
Address,
PCEPRequest
Forward
Update State
to
computation handler
PCE Protocol
Map(Address,Socket)
Selector
Sockets
• Governs the processing of
PCEP message based on State
Machine
• All state machine transitions
based on either incoming
messages or timeouts
• State machines implemented
as objects with Session
Handler and Timer initiating
State Changes
In Msg.
In Msg.
In Msg.
New Conn
Socket
RequestPCEP
SentRequest
to Computation
Arrives Layer
11
Session Handler Overview
Thread Pool
Computation Handler
Graph Library
PCEP
Response
Reset Timeout Event
Timer
State Machines
Map(Address,Statemachine)
Session Handler
ForwardState
Update
to Network
Layer
Address,
PCEPResponse
PCE Protocol
Map(Address,Socket)
Selector
Sockets
In Msg.
In Msg.
In Msg.
New Conn
Socket
• Governs the processing of
PCEP message based on
State Machine
• All state machine transitions
based on either incoming
messages or timeouts
• State machines
implemented as objects
with Session Handler and
Timer initiating State
Changes
Response
Response
received
sentfrom
to Network
Computation
Layer Layer
11
Computation Layer Overview
Assign request to
Send Response to
available thread
Computation Handler
in thread pool
Thread Pool
Computation Handler
Use Graph Lib to
compute path
Graph Library
PCEP
Request
PCEP
Response
Timer
State Machines
Session Handler
Map(Address,Statemachine)
PCE Protocol
Map(Address,Socket)
• Responsible for Processing
Path Computation Requests
• Use of custom Thread pool
to serve multiple
computation requests in
parallel
• A Java Graph Library is used
to provide topology
information acting as TED
Selector
Sockets
In Msg.
In Msg.
In Msg.
New Conn
Socket
Request
Send
Path
Response
received
Computation
To
from
Session
Completed
Session
Handler
Handler
12
Outline
• PCE architecture Overview
• PCE Emulator
• PCE Server Implementation
• PCE Client Implementation
• Challenges In Implementation
20
PCE Client Implementation
Client (GUI Implementation)
State Machine Interface: Timer
//Update state due to incoming message from Network
State Machines
Void updateStateNL(PCEPMessage);
Map(Address,Statemachine)
Session Handler
//Update
state due to message from local Client
Void updateStateClient(PCEPMessage);
//Update state due to a timeout
Void updateState(ID nextState);
PCE Protocol
Map(Address,Socket)
• Uses the same Session
Handler and Network Layer
Implementation
• The State Machine provides
interface for incoming
messages from Client to the
Session Handler
• Implemented as a simple
GUI in the Emulator
Selector
Sockets
In Msg.
In Msg.
In Msg.
New Conn
Socket
12
PCE Client GUI
Server Address
Source Address
Dest Address
Flags
Event/Message Logging Window
12
Outline
• PCE architecture Overview
• PCE Emulator
• PCE Server Implementation
• PCE Client Implementation
• Challenges In Implementation
23
Challenges in Implementation
• Coordination with TED
– TED implementations should be optimized for concurrent access
– In order to ensure accurate path information, TED update
announcement should be integrated into the PCE
– Current implementation pauses processing of new requests, updates
TED and restarts processing of active requests (not optimal)
• Integration of Security Features
– Intelligence in network layer to identify and deal with DDoS attacks
• Implementing Priority and Load balancing
– Implementing priority queuing for critical path computation requests
(e.g. backup path computation)
– Load-balancing across multiple PCEs implemented in same network
13