RFC 5671
Applicability of the Path Computation Element (PCE) to Point-to-Multipoint (P2MP) MPLS and GMPLS Traffic Engineering (TE)
Part 1 of 4 🎀 RFC 5671: PCE for P2MP MPLS & GMPLS TE
Applicability of the Path Computation Element (PCE) to Point-to-Multipoint (P2MP) MPLS and GMPLS Traffic Engineering (TE)
Okay bestie, let's start with the facts 🧚
- Network Working Group: this is an IETF document.
- RFC number: 5671
- Authors: S. Yasukawa (NTT) and A. Farrel, Ed. (Old Dog Consulting). Farrel is the editor 💅
- Category: Informational 🌸 This memo gives information to the Internet community. It does not specify an Internet standard of any kind.
- Date: October 2009
- Obsoletes and updates: the title block doesn't list any RFC that this one obsoletes or updates.
Here's the table of contents, copied exactly 📋
1. Introduction ....................................................2
2. Architectural Considerations ....................................4
2.1. Offline Computation ........................................4
2.2. Online Computation .........................................4
2.2.1. LSR Loading .........................................5
2.2.2. PCE Overload ........................................6
2.2.3. PCE Capabilities ....................................6
3. Fragmenting the P2MP Tree .......................................7
4. Central Replication Points ......................................8
5. Reoptimization and Modification .................................9
6. Repair .........................................................10
7. Disjoint Paths .................................................11
8. Manageability Considerations ...................................11
8.1. Control of Function and Policy ............................11
8.2. Information and Data Models ...............................11
8.3. Liveness Detection and Monitoring .........................12
8.4. Verifying Correct Operation ...............................12
8.5. Requirements on Other Protocols and Functional
Components ................................................12
8.6. Impact on Network Operation ...............................13
9. Security Considerations ........................................13
10. Acknowledgments ...............................................13
11. References ....................................................13
11.1. Normative References .....................................13
11.2. Informative References ...................................131. Introduction ✨
Okay so the Path Computation Element (PCE), which is defined in [RFC4655], is an entity that can compute a network path or route based on a network graph and apply computational constraints to it 🧠 The whole point is that the PCE computes the path for Traffic Engineered Label Switched Paths (TE LSPs) inside Multiprotocol Label Switching (MPLS) and Generalized MPLS (GMPLS) networks. Main character energy, honestly 👑
[RFC4655] describes a bunch of deployment models that put PCEs in different spots in the network 🗺️ A PCE might be collocated with the Label Switching Routers (LSRs). It might be part of the management system that asks for the LSPs to be set up. Or it might be one or more computation servers sitting somewhere in the network.
Requirements for point-to-multipoint (P2MP) MPLS TE LSPs are written up in [RFC4461], and the signaling protocol extensions for setting up P2MP MPLS TE LSPs are defined in [RFC4875] 📝 In this document, P2MP MPLS TE networks are looked at as the thing that supports various features. Those include layer 3 multicast VPNs [RFC4834], video distribution, etc. 🎬
Now, the big deal with P2MP LSPs is picking the branch points 🌳 That choice is limited by the network topology and the resources that are actually available. It also depends on the objective functions that get applied to path computation, which is a lot. For example, one standard objective is to minimize the total cost of the tree, meaning the sum of the costs of each link the tree traverses. That produces what's known as a Steiner tree 💅 Another common objective function requires that the cost to reach each leaf of the P2MP tree be minimized.
Picking branch points gets even messier because not every LSR in the network can necessarily do branching 🙈 That info may be recorded in the Traffic Engineering Database (TED) that the PCE uses for its computations. It may also have been distributed using extensions to the Interior Gateway Protocol (IGP) running in the network [RFC5073].
Network policies can also dictate specific branching behavior 📜 For instance, it might be decided that for certain types of LSPs in certain types of networks, no branch LSR should be responsible for handling more than a certain number of downstream branches for any one LSP. Why? Because the replication mechanism at the LSRs can be a round-robin copying process. That process delays the data transmission on each downstream branch by the time it takes to replicate the data onto each previous downstream branch. Rude 😭 Alternatively, administrative policies might say replication should be concentrated on specific key replication nodes that behave like IP multicast rendezvous points. That could be to make sure receivers in the P2MP tree are policed properly, or to make protection and resiliency easier to set up 🛡️
Path computation for P2MP TE LSPs is a seriously big challenge 😤 The reason is the complexity of all the computations described above. Working out disjoint protection paths for P2MP TE LSPs can add a lot to that complexity. Small changes to a P2MP tree, like adding or removing just one leaf, can completely change the optimal path. Reoptimizing a network with multiple P2MP TE LSPs also takes a lot of computational resources. So an ingress LSR might not have enough processing power to do all of this. Even if it does, doing the path computation might interfere with the control and management plane operations needed to keep existing LSPs running. That's where the PCE architecture comes in, because it offers a way to offload these path computations from the LSRs 🫶
2. Architectural Considerations 🏛️
2.1. Offline Computation 🌙
Offline path computation happens ahead of time, before the LSP setup is requested 🗓️ That means it's requested by a management application, or it's performed as part of one. You can see this model in Section 5.5 of [RFC4655].
The offline model is especially suited to long-lived LSPs, like the ones you find in a transport network, or to planned responses to network failures. In these situations, more planning is normally part of LSP provisioning 📋
This model may also be used when the network operator wants to keep full manual control over where LSPs are placed. The PCE is only used as a computation tool to help the operator. It's not part of an automated network 🕹️
Offline path computation can also run as a background activity for network reoptimization. It figures out whether and when the current LSP placements are significantly sub-optimal 👀 See Section 5 for further discussion of reoptimization.
2.2. Online Computation ⚡
Online path computation happens on demand, as LSRs in the network decide they need to know which paths to use for LSPs. So every computation is triggered by a request from an LSR 💖
As described in [RFC4655], the path computation function for online computation can be collocated with the LSR that makes the request. Or it can be present in a computation-capable PCE server within the network. That PCE server could be another LSR in the network, a dedicated server, or a functional component of a Network Management System (NMS). Also, the computation isn't always done by a single PCE working on its own. It may be the result of cooperation between several PCEs 🤝
The rest of this document refers to these different online models a lot. The point is to show which one fits better in different P2MP scenarios 🦋
(More to come in Part 2! Don't go anywhere 🫶💜)
2.2.1. LSR Loading ✨
Okay so this part is lowkey the heart of why P2MP path computation is a whole thing 💅. Computing a least-cost-to-leaf tree is basically the same amount of work as computing one optimal path to each leaf, one after another 🧚. A Steiner tree is way heavier, around an order of magnitude more work, though there are algorithms that approximate Steiner trees in roughly the same time as a least-cost-to-leaf tree 🔥.
Now, lots of LSRs can handle a simple Constrained Shortest Path First (CSPF) computation for one point-to-point (P2P) LSP, no problem 🎀. But if they get asked to do a bunch of those at once, like when they're recovering from a network failure, they totally get swamped 😭. So it's pretty reasonable to expect that an LSR would struggle with a P2MP path computation for a tree with lots of destinations 💀.
An LSR getting overloaded by a P2MP computation can cause two kinds of mess. First, the LSR might not be able to give timely path computations for P2P LSPs, which can slow down LSP setup for simple demand-based services and make it harder for the LSR to bounce back from network faults 🙈. Second, the LSR's processing power gets pulled away from other important stuff, like keeping up the control plane protocols that existing LSPs and forwarding state depend on 🫶. It is obviously super important that existing traffic does not get disrupted just because someone is computing a path for a new LSP 🛑.
It's also not reasonable to expect the ingress LSRs of P2MP LSPs to be specially powerful and able to do P2MP computations 🙅♀️. You could fix the overloading by requiring every LSR that forms an ingress to a P2MP LSP to be high-capacity enough for P2MP computations, but that is not an acceptable solution. In every other sense, the ingress to a P2MP LSP is just a normal ingress LSR, so it doesn't make sense to make it special 🌸.
So the obvious answer is: offload P2MP path computations from LSRs to remotely located PCEs 👑. That PCE function can live on dedicated or high-capacity network elements, like dedicated servers, or high-end routers that might be located as Autonomous System Border Routers - ASBRs 🦋.
2.2.2. PCE Overload ✨
P2MP path computations are seriously resource-intensive 😤. So when you bring P2MP LSPs into an established PCE network, the PCEs might get overloaded. The P2MP computations could block other P2P computations and might even overload the PCE itself 💀.
There are a few ways to ease this within the PCE architecture, as described in [RFC4655] 💖. For example, the LSRs that issue path computation requests can assign them priorities. So the LSRs could give P2MP requests a lower priority, making sure P2P requests get serviced first 🍓. On top of that, PCEs can apply local and network-wide policy, and that policy may dictate specific processing rules [RFC5394] 🧠.
But ultimately, a network needs enough path computation resources for what it needs, and within the PCE architecture, the way to get there is simply adding more PCEs 🌈.
Once there are enough PCEs in the network, LSRs can pick between them. They can also use the overload notification information that PCEs supply to spot which PCEs are currently overloaded 👀. And if a PCE starts getting overloaded, it can pass its queue of computation requests along (using the PCE cooperation model described in [RFC4655]) to other, less burdened PCEs in the network 🫶✨.
2.2.3. PCE Capabilities ✨
An LSR gets to choose between the available PCEs and pick the one most likely to actually be able to do the requested path computation 🎯. That choice might be based on overload notifications from the PCEs, but it could also look at other computational capabilities 💅.
For example, it's quite likely that only a subset of PCEs in the network can do P2MP computations, because that takes advanced functionality 🔥. Some of those PCEs might be able to satisfy certain objective functions (for example, least cost to destination) but not others (for example, Steiner) 🙈. And some PCEs might not be capable of the more complex P2MP reoptimization functionality either 😭.
The PCE architecture lets an LSR discover the capabilities of the PCEs in the network at the same time it discovers they exist ✨. Even more detailed exchanges of PCE capabilities can happen directly between the PCEs and the LSRs 🤝. This exchange of PCE capabilities information lets a Path Computation Client (PCC) pick the PCE that can best answer its computation requests 👑.
3. Fragmenting the P2MP Tree 🧩
Okay, so one way to lighten the computational load of computing a big P2MP tree on a single PCE is to fragment or partition the tree 🦋. This is especially obvious in a multi-domain network (such as multiple routing areas), but it works in a single domain too 💖.
Check out the network topology in Figure 1 🌸. A P2MP LSP is required from ingress LSR A to egress LSRs s, t, u, v, w, x, y, and z 🫶. In a single PCE model, LSR A can request the entire path of the tree, and the PCE can hand it right back 💅. Or, the PCE that LSR A consults might only compute the first fragment of the tree (for example, from A to K, L, and M). Then it can rely on other PCEs to compute the three smaller trees: from K to t, u, and v; from L to w and x; and from M to s, y, and z 🧚.
t
/
/
n--u
/
/
e--f--h--K--o--v
/
/
A--b--c--d--g--i--L--p--w
\ \
\ \
j x
\
\
M--r--y
\ \
\ \
s z
Figure 1: A P2MP Tree with Intermediate Computation PointsThe LSR that LSR A consulted can just return the first subtree and let LSRs K, L, and M invoke PCEs in their own turn to finish the signaling 🎀. Or, the first PCE can team up with other PCEs to collect the paths for the later subtrees and send them back in one single computation response to PCE A 🤝. The mechanisms for both of these approaches are described in the PCE architecture [RFC4655] ✨.
A further possibility is that the LSRs where the subtrees get stitched together (K, L, and M in this example) are picked from a set of potential points using a cooperative PCE technique, like the Backward Recursive Path Computation (BRPC) mechanism [RFC5441] 🔥. Honestly, if LSRs K, L, and M were ASBRs or Area Border Routers (ABRs), BRPC would be a perfect fit 👑.
Now, these mechanisms are superficially beneficial, but it is far from obvious how the first LSR picks the transit LSRs K, L, and M, or how the leaf nodes get assigned to be downstream of particular downstream nodes 🙃. Figuring that out might be just as intensive as computing the full tree, unless there is some known property of the leaf node identifiers, like the kind that address aggregation might provide 🧐.
4. Central Replication Points 💜
One deployment model for P2MP LSPs is to use centralized, well-known replication points 🌟. You might choose this for administrative or security reasons, or because of particular hardware capability limits in the network 🔐. In fact, this deployment model can be achieved with P2P LSPs between the ingress and the replication point, plus P2P LSPs between the replication point and each leaf. That gives you a P2MP service without using P2MP MPLS-TE 🦋.
The motivations for this kind of deployment are beyond the scope of this document, but it's worth looking at how PCE might be used to support this model 🎀.
In Figure 2, a P2MP service is required from ingress LSR a to egress LSRs m, n, o, and p 💖. There are four replication-capable LSRs in the network: D, E, J, and K 🌸.
When LSR a consults a PCE, it could be handed the full P2MP path from LSR a to the leaves. But in this model, the PCE just returns a P2P path to the first replication point (in this case, LSR D) 🧚. LSR D then consults a PCE in its turn and determines the P2P LSPs to egress LSRs m and p, as well as the P2P LSP to the next replication point, LSR J 🫶. Finally, LSR J uses a PCE to determine P2P LSPs to egresses n and o 👑.
f--i--m
/
/
a--b--c--D--g--J--n
\ \
\ \
E h K o
\
\
l--p
Figure 2: Using Centralized Replication PointsIn this model of operation, the PCE function is quite likely located at the replication points, which will be high-capacity LSRs 💅. One of the main features of the computation activity is selecting the replication points. For example, why is LSR D selected over LSR E, and why is LSR J chosen over LSR K? 🤔 This selection may be made solely on the basis of path optimization, the same way it would be for a P2MP computation. But it may also be influenced by policy issues (for example, LSR D may be able to give better security to protect against rogue leaf attachment) or by network loading concerns (for example, LSR E may already be handling a very large amount of traffic replication for other P2MP services) 🔥✨.
5. Reoptimization and Modification ✨
okay so once a P2MP LSP is up and running, it's way more sensitive to changes than its P2P cousin 🥺 if you remove an egress from a P2P LSP, the whole thing gets torn down 💀 but with P2MP, egresses can be added and removed as receivers come and go 🦋 main character energy fr.
removing an egress from a P2MP LSP doesn't need any new path computation at all, because the tree can just get automatically pruned ✂️
adding a new egress is a bit more involved, but still pretty chill 💅 you compute an appropriate branch point, then figure out a P2P path from that branch point to the new egress. it's a relatively simple computation and it can be done with reverse-path CSPF, kinda like how some multicast IP routing protocols do it 🌸
BUT here's the tea 🍵 repeated adding and removing will almost certainly leave the LSP in a sub-optimal state. the tree shape that was optimal for the original set of destinations gets distorted by all those changes, so it won't be optimal for the new set of destinations 😭
and it gets worse 🙈 as resource availability changes in the network (other LSPs get released, or new network resources come online), the path of the P2MP LSP may become sub-optimal too.
computing a new optimal path for the P2MP LSP is as simple as computing any optimal P2MP path. the tricky part is picking a path that can actually be applied within the network as a migration from the existing LSP, and that can be more complex 🧩 the network administrator may also apply additional constraints so that only subsets of the egresses (or subtrees of the P2MP tree) get optimized at any one time. in these cases the computational load of reoptimization may be considerable, but luckily reoptimization computations may be performed as background activities ✨ splitting the P2MP tree into subtrees, as described in Section 3, may further reduce the computation load and may help with administrative preferences for partial tree reoptimization 🎀
network-wide reoptimization of multiple LSPs [RFC5557] can get way better optimality in overloaded networks than reoptimizing LSPs one by one 👑 that kind of computation would typically be performed offline and would usually need a dedicated processor, like a PCE invoked by the NMS 💜
6. Repair
LSP repair is needed when a network fault disrupts the LSP's ability to deliver data to an egress 🚨 for a P2MP LSP, a network fault is (statistically) likely to only impact a small subset of the total egresses. so repair doesn't need to recompute the path of the entire P2MP tree 🙌 instead it needs to quickly find suitable new branches that can get grafted onto the existing tree to reconnect the disconnected leaves 🌿
right after a network failure there may be a huge number of path computations needed to restore multiple P2P and P2MP LSPs 😩 the PCEs will be heavily loaded, so it's important that computation requests are restricted to only the 'essential' ones 🫶
so it's useful to know that the simple repair computations from the first paragraph of this section may be applied for a first repair of the LSPs. the more sophisticated reoptimization computations can wait until the network is stable and the PCE load has dropped 🧁 those reoptimizations can be computed as described in Section 5.
7. Disjoint Paths
disjoint paths are required for end-to-end protection services and sometimes for load balancing ⚖️ they may need to be fully disjoint (except at the ingress and egress!), link disjoint (common nodes on the paths are allowed), or best-effort disjoint (shared links or nodes are allowed when no other path can be found) 💅
computing disjoint paths one after another is possible, but this can lead to blocking problems where the second path just can't be placed 🙃 those issues are more easily avoided if the paths are computed in parallel ✨
computing link disjoint P2P paths can be non-trivial, and it may be the kind of task an LSR offloads to a PCE because of its complexity 🧠 computing disjoint P2MP paths is considerably harder, so it's a good candidate to offload to a PCE that has dedicated resources 💪 it may well be the case that not all P2MP-capable PCEs can handle disjoint path requests, so it may be necessary to choose between PCEs based on their capabilities 🦋
8. Manageability Considerations 🎀
using a PCE to compute P2MP paths has many of the same manageability considerations as using it for P2P LSPs [RFC5440]. there may be extra manageability implications for the size of P2MP computation requests and the additional loading on the PCEs 📦
8.1. Control of Function and Policy
as already described, individual PCEs may choose not to be capable of P2MP computation. where this function is available, an operator may disable it, or it may be automatically withdrawn when the PCE gets loaded, or based on other policy considerations 🫠
a PCE may also refuse any P2MP computation request, or pass it on to another PCE based on policy 🙅♀️
8.2. Information and Data Models
P2MP computation requests need way more information exchange between the LSR and the PCE than P2P computations do 📚 this means much larger data sets to control and model, and it will impact the usefulness of any management data models, such as MIB modules 😵 care needs to be taken when designing those data models. the use of other management protocols and data modeling structures, such as NETCONF [RFC4741] and the NETCONF Data Modeling Language (NETMOD), could be considered 💖
8.3. Liveness Detection and Monitoring
PCE liveness detection and monitoring is unchanged from P2P operation, but heads up: P2MP requests will take longer to process than P2P requests, so the time between request and response will be, on average, longer ⏳ that raises the chance of a communications failure between request and response, which means liveness detection is more important 🚦
8.4. Verifying Correct Operation
correct operation of any communication between LSRs and PCEs is exactly as important as it is for P2P computations 🤝
the correct operation of path computation algorithms implemented at PCEs is out of scope. but LSRs that are worried that PCE algorithms might not be operating correctly may make identical requests to separate PCEs and compare the responses 🕵️♀️
8.5. Requirements on Other Protocols and Functional Components
as is clear from the PCE architecture, a communications protocol is needed so LSRs can send computation requests to PCEs and so PCEs can cooperate 🗣️ requirements for a protocol handling P2P path computations are described in [RFC4657], and additional requirements to support P2MP computations are described in [PCE-P2MP]. the PCE Communication Protocol (PCEP) is defined in [RFC5440], but extensions will be necessary to support P2MP computation requests 🧩
as described in the body of this document, LSRs need to be able to recognize which PCEs can perform P2MP computations 👀 capability advertisement is already present in the PCE Discovery protocols ([RFC5088] and [RFC5089]) and can also be exchanged in PCEP ([RFC5440]), but extensions will be required to describe P2MP capabilities 🌈
as also described in this document, the PCE needs to know the branch capabilities of the LSRs and store this information in the TED. this information can be distributed using the routing protocols as described in [RFC5073] 🗂️
8.6. Impact on Network Operation
using a PCE to perform P2MP computations may have a beneficial impact on network operation if it can offload processing from the LSRs, freeing them up to handle protocol operations 🌷
plus, using a PCE may enable more dynamic behavior in P2MP LSPs (like adding new egresses, reoptimization, and failure recovery) than is possible with more traditional management-based planning techniques 🧚
9. Security Considerations 🔐
using a PCE to compute P2MP paths doesn't raise any additional security issues beyond the ones that generally apply to the PCE architecture 🛡️ see [RFC4655] for a full discussion.
but here's the scary part 😱 P2MP computation requests are more CPU-intensive and also use more link bandwidth. so if the PCE got attacked by the injection of spurious path computation requests, it would be more vulnerable through a smaller number of those requests 🚨
so the use of message integrity and authentication mechanisms within the PCE protocol should be used to mitigate attacks from devices that aren't authorized to send requests to the PCE 🔒 it would also be possible to consider applying different authorization policies for P2MP path computation requests compared to other requests 🗝️
10. Acknowledgments 🫶
the authors would like to thank Jerry Ash and Jean-Louis Le Roux for their thoughtful comments 💕 Lars Eggert, Dan Romascanu, and Tim Polk provided useful comments during IESG review 🌸
11. References 📚
11.1. Normative References
[RFC4655] Farrel, A., Vasseur, J.-P., and J. Ash, "A Path
Computation Element (PCE)-Based Architecture", RFC 4655,
August 2006.11.2. Informative References 📚
okay bestie, these are the "good to know" reads 💅 nothing here is strictly required to implement the thing, but they're the background drama that explains where all the PCE and MPLS-TE stuff came from 🦋
- [RFC4461] Yasukawa, S., Ed., "Signaling Requirements for Point-to-Multipoint Traffic-Engineered MPLS Label Switched Paths (LSPs)", RFC 4461, April 2006.
- [RFC4657] Ash, J., Ed., and J. Le Roux, Ed., "Path Computation Element (PCE) Communication Protocol Generic Requirements", RFC 4657, September 2006.
- [RFC4741] Enns, R., Ed., "NETCONF Configuration Protocol", RFC 4741, December 2006.
- [RFC4834] Morin, T., Ed., "Requirements for Multicast in Layer 3 Provider-Provisioned Virtual Private Networks (PPVPNs)", RFC 4834, April 2007.
- [RFC4875] Aggarwal, R., Ed., Papadimitriou, D., Ed., and S. Yasukawa, Ed., "Extensions to Resource Reservation Protocol - Traffic Engineering (RSVP-TE) for Point-to-Multipoint TE Label Switched Paths (LSPs)", RFC 4875, May 2007.
- [RFC5073] Vasseur, J., Ed., and J. Le Roux, Ed., "IGP Routing Protocol Extensions for Discovery of Traffic Engineering Node Capabilities", RFC 5073, December 2007.
- [RFC5088] Le Roux, JL., Ed., Vasseur, JP., Ed., Ikejiri, Y., and R. Zhang, "OSPF Protocol Extensions for Path Computation Element (PCE) Discovery", RFC 5088, January 2008.
- [RFC5089] Le Roux, JL., Ed., Vasseur, JP., Ed., Ikejiri, Y., and R. Zhang, "IS-IS Protocol Extensions for Path Computation Element (PCE) Discovery", RFC 5089, January 2008.
- [RFC5394] Bryskin, I., Papadimitriou, D., Berger, L., and J. Ash, "Policy-Enabled Path Computation Framework", RFC 5394, December 2008.
- [RFC5440] Vasseur, JP., Ed., and JL. Le Roux, Ed., "Path Computation Element (PCE) Communication Protocol (PCEP)", RFC 5440, March 2009.
- [RFC5441] Vasseur, JP., Ed., Zhang, R., Bitar, N., and JL. Le Roux, "A Backward-Recursive PCE-Based Computation (BRPC) Procedure to Compute Shortest Constrained Inter-Domain Traffic Engineering Label Switched Paths", RFC 5441, April 2009.
- [RFC5557] Lee, Y., Le Roux, JL., King, D., and E. Oki, "Path Computation Element Communication Protocol (PCEP) Requirements and Protocol Extensions in Support of Global Concurrent Optimization", RFC 5557, July 2009.
- [PCE-P2MP] Yasukawa, S., and Farrel, A., "PCC-PCE Communication Requirements for Point to Multipoint Multiprotocol Label Switching Traffic Engineering (MPLS-TE)", Work in Progress, May 2008.
Authors' Addresses 🎀
the people who made it all happen, with their contact info ✨
Seisho Yasukawa
NTT Corporation
9-11, Midori-Cho 3-Chome
Musashino-Shi, Tokyo 180-8585,
Japan
EMail: yasukawa.seisho@lab.ntt.co.jp
Adrian Farrel
Old Dog Consulting
EMail: adrian@olddog.co.uk📦 where this page comes from
- ietf: rfc5671 2009-10
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms