Improved segment identifier assignment

Abstract

The segment identifier (SID) manager interfaces with clients through a library. Clients implement network services and require Internet SRv6 segment identifiers. They use the library to be assigned a block of segment identifiers by the segment identifier manager. Clients use the library to allocate segment identifiers from the block independently of the segment identifier manager. When the allocated portion of the block reaches a threshold, the library requests additional blocks of segment identifiers from the segment identifier manager. Clients send a context map of the allocated segment identifiers to the segment identifier manager for administrative use and failure recovery.

Description

[Technical Field]

[0001] Segment routing over the IPv6 data plane (SRv6) defines segment routing over the Internet Protocol version 6 (IPv6) protocol for routing segments over a data plane, such as a router or the data plane of other network devices, including many connected routers, switches, or other network elements, server computers, or other computing devices. [Background technology]

[0002] According to SRv6, the routing of a packet is encoded within the packet by a segment identifier (SID) that defines the routing of the packet through the data plane. Summary of the Invention [Problem to be solved by the invention]

[0003] This application relates to an improved approach to assigning segment identifiers in systems that include an IPv6 data plane. [Means for solving the problem]

[0004] To solve the above problems, the present invention provides a system and method as claimed in the claims.

[0005] In order that the advantages of the present invention may be readily understood, a more particular description of the invention, briefly described above, will now be set forth with reference to specific embodiments thereof which are illustrated in the accompanying drawings, which are to be understood as illustrating only typical embodiments of the invention and are therefore not intended to limit the scope of the invention, and which will be described in detail and with additional particularity using the accompanying drawings. [Brief explanation of the drawings]

[0006] [Figure 1]FIG. 2 is a schematic block diagram of components for implementing low latency segment identifier allocation according to an embodiment of the present invention. [Figure 2] FIG. 2 is a process flow diagram of a method for managing segment identifier assignment according to an embodiment of the present invention. [Figure 3] FIG. 1 is a process flow diagram for performing multi-thread allocation according to an embodiment of the present invention. [Figure 4] FIG. 2 is a process flow diagram of a method for restoring a context map according to an embodiment of the present invention. [Figure 5] FIG. 1 is a schematic diagram of a computer system suitable for implementing methods according to embodiments of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0007] It will be readily understood that the components of the present invention, as illustrated and described in the accompanying drawings, could be designed and arranged in a wide variety of different configurations. Thus, the following more detailed description of the illustrated embodiments of the invention is not intended to limit the scope of the invention as set forth in the claims, but merely to illustrate specific examples of embodiments in accordance with the present invention being discussed herein. The embodiments described herein can best be understood by referring to the drawings, wherein like parts are designated with like reference numerals throughout the specification and drawings.

[0008] Embodiments in accordance with the present invention may be embodied as an apparatus, a method, or a computer program product. Accordingly, the present invention may be embodied in the form of an entirely hardware form, an entirely software form (including firmware, resident software, microcode, etc.), or a combination of hardware and software, generally referred to herein as a "module" or "system." Furthermore, the present invention may take the form of a computer program product embodied in any tangible medium of expression having computer-usable program code embodied in the medium.

[0009] Any combination of one or more computer usable or computer readable media may be utilized. For example, computer readable media may include one or more of a portable computer diskette, a hard disk, a random access memory (RAM) device, a read only memory (ROM) device, an erasable programmable read only memory (EPROM or flash memory) device, a portable compact disc read only memory (CDROM), an optical storage device, and a magnetic storage device. In selected embodiments, computer readable media may include any non-transitory medium that can contain, store, communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.

[0010] Computer program code for carrying out operations of the present invention can be written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Java, Smalltalk, C++, and conventional procedural programming languages ​​such as the C programming language or similar programming languages, and can also use script or markup languages ​​such as HTML, XML, JSON, etc. The program code can be executed entirely on the computer system as a standalone software package, on a standalone hardware unit, partially on a remote computer located some distance from the computer, or entirely on a remote computer or server. In the latter scenario, the remote computer can be connected to the computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or can be connected to an external computer (e.g., via the Internet using an Internet Service Provider).

[0011] The present invention is described below with reference to flowcharts and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. Each block of the flowcharts and / or block diagrams, and combinations of blocks in the flowcharts and / or block diagrams, can be implemented by computer program instructions or code. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus, and can produce a machine such that the instructions, executed by the processor of the computer or other programmable data processing apparatus, generate means for implementing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0012] These computer program instructions may also be stored on a non-transitory computer-readable medium that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable medium produce an article of manufacture that includes instruction means that implement the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0013] Computer program instructions are also loaded onto a computer or other programmable data processing apparatus and cause a series of operational steps to be performed on the computer or other programmable data processing apparatus to create a computer-implemented process, such that the instructions, when executed on a computer or other programmable data processing apparatus, provide a process for implementing the functions / acts identified in one or more blocks of the flowcharts and / or block diagrams.

[0014] 1 illustrates an example architecture 100 for assigning segment identifiers (SIDs). The components illustrated may represent components executable on a separate computer system. The computer system may be embodied as a single computing device, a server rack with multiple servers attached to a common backplane, or other type of computing device.

[0015] The architecture 100 may include a segment identifier manager 102. The segment identifier manager 102 assigns segment identifiers to clients 104 executing on a computer system. The segment identifier manager 102 assigns segment identifiers such that each segment identifier is globally unique among all clients 104. As described in more detail below, segment identifiers may be assigned in blocks of, for example, 1000 to 2000 segment identifiers at a time, to reduce latency at the clients 104 and reduce loads on the segment identifier manager 102 as well.

[0016] Each client 104 may implement a network protocol or portion of a network protocol, such as the Intermediate System-Intermediate System (IS-IS) protocol, the Open Shortest Path First (OSPF) protocol, the Border Gateway Protocol (BGP), or static routing. The client 104 may implement Segment Routing over IPv6 (SRv6) and may use segment identifiers received from the segment identifier manager 102 in accordance with that protocol. In particular, each segment identifier assigned to a client 104 may be associated by the client 104 with a forwarding behavior, i.e., packets labeled with that segment identifier are routed by that client 104 to other clients 104, external addresses, or other components or computing devices according to the forwarding behavior associated with that segment identifier. This association of segment identifiers and forwarding behaviors is referred to herein as a context map.

[0017] Client 104 can interface with segment identifier manager 102 through segment identifier library 106. Client 104 can link to library 106 in any manner known to those skilled in the art. For example, the library can be a dynamic link library (DLL) such as those used in Microsoft Windows operating systems, which client 104 can load at instantiation time, thereby providing client 104 with functions to access segment identifier manager 102 in the manner disclosed herein. Segment identifier library 106 can be a library of functions defined in UNIX, LINUX, or other operating systems. For example, segment identifier library 106 can be a shared object library that dynamically links to client 104 at run time.

[0018] The segment identifier manager 102 may interact with clients 104 to allocate blocks of segment identifiers and maintain segment identifier data 108 describing these allocations. For example, for a particular client 104 with an associated client identifier 110, the segment identifier data 108 may include allocation 112 that lists those segment identifiers assigned to the client 104.

[0019] In some embodiments, as described below, each client 104 can periodically send its context map to the segment identifier manager 102, for example, through functions provided in the segment identifier library 106. These context maps can be stored as context maps 114 within the segment identifier data 108 of that client 104. These context maps 114 can be displayed to an administrator to enable monitoring of the state of the client 104. The context maps 114 can also be used to restore the state of the client 104 during client 104 execution or in the event of client 104 failure in a computer system. To that end, the context maps 114 can be checkpointed and stored in persistent storage to enable restoration of the client 104 to the checkpoint state in the event of a failure or when a rollback to a previous state is indicated. The client 104 can provide its context map 114 to the segment identifier manager 102, which can restore the state of the client 104 from the context map 114 using functions in the segment identifier library 106.

[0020] Each client 104 may similarly store a context map 118 and segment identifier assignments 116 for each segment identifier associated with the context map. Management of the segment identifiers assigned to a client 104, i.e., recording the assignment of individual segment identifiers to context maps and the assignment of blocks of segment identifiers, may be performed through functions of the segment identifier library 106.

[0021] Clients 104 are connected to one another by a data plane 120. Segment identifiers can be used to route packets labeled with the segment identifier between clients 104 through the data plane 120. This can be done by any approach known to those skilled in the art, particularly IPv6. Data plane 122 can be further connected to a network 122, through which segment identifiers are used to route packets to and from other computer systems.

[0022] The methods disclosed herein describe the allocation of blocks of segment identifiers that are particularly useful for IPv6, but may also be applied to other situations where a source is requesting the allocation of values ​​to multiple clients, such that each value is a client-unique value assigned to only one client.

[0023] 2 illustrates a method 200 performed using the architecture 100. In particular, the method 200 may be performed for each client 104. The method 200 may include invoking 202 the segment identifier library 106. In particular, a client 104, upon startup, may link to the segment identifier library 106 and invoke a function, such as an initialization function. As a result of this function, the segment identifier library 106 may instruct the segment identifier manager 102 to assign 204 a block of segment identifiers to the client 104. As described above, the segment identifier manager 102 ensures that all segment identifiers within the block of segment identifiers are globally unique with respect to segment identifiers assigned to other clients 104. The allocation 204 of the block of segment identifiers may be performed automatically upon instantiation of the client 104 or in response to an explicit function call by the client 104 after startup, the function call being defined in the segment identifier library 106.

[0024] The method 200 may further include starting 206 a thread of execution defined in the segment identifier library 106 within the process of the client 104, the thread performing periodic transfers of the client's 104 context map 118 to the segment identifier manager 102. The thread is preferably assigned a low priority so as not to interfere with other operations of the client 104. The thread may be woken up to run either (a) at a fixed minimum period, or (b) in response to loading of the computer system hosting the client 104 dropping below a particular level.

[0025] The method 200 further includes assigning 208, by the client 104, a segment identifier to the context map. As noted above, this can include the client 104 associating the segment identifier with a forwarding behavior, where the forwarding behavior applies to packets labeled with that segment identifier. This can be performed using library calls defined in a segment identifier library. Notably, in some embodiments, the client 104 does not need to know or manage blocks of segment identifiers, but can request a segment identifier similar to other approaches in the art. However, the segment identifier provided to the client 104 is one of a block of segment identifiers previously assigned to the client 104 and returned to the client 104 for use without having to wait for a response from the segment identifier manager 102.

[0026] Method 200 further includes evaluating 210 usage of the block of segment identifiers assigned to client 104. If usage is found to be above a threshold, for example, if more than 50% of the segment identifiers have been assigned to the context map, then method 200 may include requesting 212 an additional block of segment identifiers from segment identifier manager 102. In this manner, there is no latency in the allocation of individual segment identifiers because the supply of assigned segment identifiers is always greater than zero. Steps 210 and 212 may be performed by a function in segment identifier library 106 and may be transparent to the client. In particular, in response to an allocation by step 208, the function in segment identifier library 106 may perform the evaluation of step 210 and request 212 an additional block of segment identifiers, with or without an explicit request from client 104.

[0027] Method 200 may include evaluating 214 whether the transfer thread from step 206 has been selected for execution by a thread manager of an operating system on the computer system or by a thread manager implemented by segment identifier library 106. If selected, then method 200 may include transferring 216 the client's context map to segment identifier manager 102. This may be performed automatically by the transfer thread, which reads the context map directly from a predetermined location in the client's 104 data and transfers the context map to segment identifier manager 102. Step 216 may include transferring only new context maps since the last execution of method 200. For example, segment identifiers may be associated with context maps in numerical order, and only context maps for segment identifiers higher than the highest segment identifier reported in the last iteration of step 216 need be transferred in the current iteration of step 216.

[0028] The method 200 may include evaluating 218 whether a failure has occurred. This may include detecting a restart of the client 104 due to an individual failure of the client 104 or a restart following a failure of the computer system hosting the client 104. In response to the occurrence of a failure, the method 200 may include obtaining 220 a context map for the client 104 from the segment identifier manager 102. This may be performed by the segment identifier library 106. For example, upon restart, upon instantiating the client 104 and relinking the client 104 with the segment identifier library 106, an initialization function may evaluate whether the context map 118 for the client 104 matches the context map 114 persistently stored by the segment identifier manager 102. If there is a mismatch, the initialization function obtains the context map 114 for the client 104 from the segment identifier manager 102 and sets it as the context map 118.

[0029] Referring to FIG. 3, a method 300 is shown that can be performed by the segment identifier manager 102 when interfacing with the segment identifier library 106 to allocate blocks of segment identifiers to clients 104. The method 300 can include starting 302 multiple allocation threads, e.g., two to ten, and assigning 304 a range of segment identifiers to each thread, where the range of segment identifiers allocated to one thread is distinct and non-overlapping with the ranges of segment identifiers allocated to all other threads. Each of the segment identifier ranges can contain a number of segment identifiers equal to hundreds or thousands of blocks. Each allocation thread interfaces with clients 104 through functions in the library 106 and performs all functions related to its allocated range of segment identifiers as described above. In particular, the allocation thread allocates blocks of segment identifiers from its allocated range, receives context map reports, maintains persistent storage of the context map reports, and restores the context map from persistent storage upon failure as described above.

[0030] When the segment identifier manager 102 discovers 306 that it has received a request for allocation of a block of segment identifiers from a client 104, i.e., from a function of a library 106 executed within the context of the client 104, the segment identifier manager 102 selects 308 one of the allocation threads, either through a round-robin or other load-balancing approach, or that is idle (not currently executing another allocation or other function). The selected allocation thread then allocates 310 a block of segment identifiers to the client 104 from which the request was received, the block of segment identifiers being allocated from the range of segment identifiers allocated to that allocation thread and being unique with respect to other blocks allocated by that allocation thread. Allocation to clients can be performed in the manner described above in conjunction with a function of the library 106.

[0031] From now on, context maps from clients that reference segment identifiers from the allocated block are processed by the allocation thread. For example, a context map report received from a client 104 that references a segment identifier from the allocated block is routed to the allocation thread, which then updates the context map 114 for the segment identifiers referenced in the report.

[0032] 4, a method 400 is shown that may be performed by the storage manager 102 in cooperation with a client 104 executing functions of the library 106 to restore the client's 104 context map from the context map 114 in the segment identifier data 108. The method 400 may be performed in response to detecting a failure, such as a failure of a node executing the segment identifier manager 102, a failure of the segment identifier manager 102, a failure of one or more clients 104, or other failure. The method 400 may be performed upon restoration of operation of a failed node or component (segment identifier manager 102 or client 104).

[0033] The method 400 may include the segment identifier manager 102 reading 402 the context map 114 from persistent storage, such as a hard drive, flash drive, or other persistent storage. The context map 114 associated with a particular client identifier 110 may be sent 404 to the client 104 to which the client identifier 110 is assigned.

[0034] The segment identifier manager 102 can further instruct 406 the client 104 to reacquire the context map from such a source of context map, particularly a configuration file, a configuration manager, or other source of network configuration data on the node executing the storage manager 102, which may be a remote node connected by a network. The method by which the client 104 acquires the configuration data to generate the context map can be by any method known to those skilled in the art. The configuration data changes over time such that the context map 114 persistently stored by the storage manager 102 becomes outdated or accurate. Therefore, the method 400 can generate instructions at step 406 to ensure that the client 104 is up to date and the context map 114 is updated.

[0035] The instructions from step 406 may further instruct the client 104 to provide updates to the storage manager 102 for: (a) any context maps obtained from the source of the configuration data that are not included in the context maps transmitted in step 404, and (b) any context maps transmitted in step 404 that are not defined in the context maps obtained from the configuration data.

[0036] The client 104 then executes those functions commanded in step 406. Execution of these commands can take time, e.g., 10 seconds to several minutes. Therefore, the context map sent in step 404 can be received and used by the client 104 to reduce downtime until an updated context map is obtained from the source of the configuration data.

[0037] Each client 104 sends changes to the context map sent in step 404, and these updates are received 408 by the segment identifier manager 102, which then updates 410 the context map 114 of that client 104 accordingly, i.e., adding new context maps and / or removing context maps that are no longer part of the context map of that client 104.

[0038] In some embodiments, context map updating 410 is performed by the segment identifier manager 102 using a flag and a countdown timer associated with the context map 114. In particular, after step 402 and / or after step 404, a countdown timer is started. The initial value of the countdown timer may be set equal to or greater than the value corresponding to the time required for a client 104 to reacquire its context map from the source of configuration data. After step 402, all context maps 114 read 402 from persistent storage are flagged as stale. In step 410, the stale flag is cleared in each context map 114 that matches a context map reported by one of the clients 104 in step 408. Steps 408 and 410 may be performed in an interleaved manner, such that the stale flag is cleared as reporters are received over a period of time. Step 410 may further include detecting expiration of the countdown timer, and in response to detecting the expiration, identifying all context maps 114 that are still marked as outdated and removing those context maps from the segment identifier data 108.

[0039] If an individual client 104 fails, the client 104 may request that its context map 114 mapped to its client identifier 110 be sent upon restart. The method may then continue with step 404 for that client 104. Multiple clients 104 may restore their context maps in a similar manner as an individual client.

[0040] 5 is a block diagram illustrating an example computing device 500 that can be used to implement the methods and systems disclosed herein. In particular, a node in the data plane that implements a segment identifier manager or any independent client can have all or some of the attributes of computing device 500.

[0041] The computing device 500 can be used to perform various processes as described herein. The computing device 500 can function as a server, a client, or other computing entity. The computing device can perform various monitoring functions as described herein and can execute one or more application programs, such as the application programs described herein. The computing device 500 can be any of a wide variety of computing devices, such as a desktop computer, a laptop, a server computer, a handheld computer, a tablet, etc.

[0042] Computing device 500 includes one or more processors 502, one or more memory devices 504, one or more interfaces 506, one or more mass storage devices 508, one or more input / output (I / O) devices 510, and a display device 530, all connected to a bus 512. Processor 502 includes one or more processors or controllers and executes instructions stored in memory device 504 and / or mass storage device 508. Processor 502 may also include various types of computer-readable media, such as cache memory.

[0043] The memory device 504 includes a variety of computer-readable media, such as volatile memory (e.g., random access memory (RAM) 514) and / or non-volatile memory (e.g., read-only memory (ROM) 516). The memory device 504 may also include re-writable ROM, such as flash memory.

[0044] The mass storage device 508 includes various computer-readable media such as magnetic tape, magnetic disks, optical disks, solid-state memory (e.g., flash memory), etc. As illustrated in Figure 5, a particular mass storage device is a hard disk drive 524. Various drives may also be included within the mass storage device 508 to allow reading from and / or writing to various computer-readable media. The mass storage device 508 includes removable media 526 and / or non-removable media.

[0045] The input / output devices 510 include various devices that allow data and / or other information to be input to or obtained from the computing device 500. Exemplary input / output devices 510 include cursor control devices, keyboards, keypads, microphones, monitors or other display devices, speakers, printers, network interface cards, modems, lenses, CCD or other imaging devices, etc.

[0046] Display device 530 includes any type of device capable of displaying information to one or more users of computing device 500. Examples of display device 530 include a monitor, a display terminal, a video projection device, etc.

[0047] The interface 506 includes various interfaces that allow the computing device 500 to exchange information with other systems, devices, or computing environments. An exemplary interface 506 includes any number of different network interfaces 520, such as interfaces to a local area network (LAN), a wide area network (WAN), a wireless network, and the Internet. Other interfaces include a user interface 518 and a peripheral interface 522. The interface 506 may also include one or more user interface elements 518. The interface 506 may also include one or more peripheral interfaces, such as interfaces for a printer, a pointing device (mouse, trackpad, etc.), a keyboard, etc.

[0048] The bus 512 allows the processor 502, memory device 504, interface 506, mass storage device 508, and input / output device 510 to communicate with each other, as well as other devices or components connected to the bus 512. The bus 512 may represent one or more of several types of bus structures, such as a system bus, a PCI bus, an IEEE 1394 bus, a USB bus, etc.

[0049] For purposes of illustration, programs and other executable program components are shown herein as separate blocks, but it is understood that such programs and components may reside at various times in different storage components of computing device 500 and be executed by processor 502. Alternatively, the systems and processes described herein may be implemented in hardware, or in a combination of hardware, software, and / or firmware. For example, one or more application-specific integrated circuits (ASICs) may be programmed to perform one or more of the systems and processes disclosed herein. [Explanation of symbols]

[0050] 100 Architecture 200 ways 300 ways 400 ways 500 computing devices 512 Bus

Claims

1. 1. A system having a computing device including one or more processing units and one or more memory units operatively connected to the one or more processing units and storing executable code, the system comprising: When the executable code is executed by the one or more processing devices, the one or more processing devices: implementing a data plane that provides routing of data between a plurality of client nodes and an external network connected to the computing device; Implementing a segment identifier manager; This causes the segment identifier manager: at each client node of the plurality of client nodes, assigning to the each client node a block of a plurality of segment identifiers, the plurality of segment identifiers being globally unique among all segment identifiers assigned to the plurality of client nodes; programmed to provide a library to the plurality of client nodes; The library, for each client node of the plurality of client nodes, generating a mapping of contexts of the plurality of contexts of each of the client nodes to the respective segment identifiers of the block of the plurality of segment identifiers, the mapping of the contexts of each of the client nodes to the respective segment identifiers being performed by each of the client nodes independent of the segment identifier manager, the mapping of the contexts of each of the client nodes to the respective segment identifiers defining how packets labeled with the respective segment identifiers are routed; periodically transmitting, by each of the client nodes to the segment identifier manager, a mapping of the individual segment identifiers of the plurality of block of segment identifiers to the plurality of contexts of the each of the client nodes; He commanded them to The system, wherein the context for each of the client nodes is a forwarding behavior associated with each of the individual segment identifiers.

2. each client node of the plurality of client nodes further comprising: Detecting a failure of each of the client nodes; and in response to detecting a failure of each of the client nodes, requesting from the segment identifier manager a mapping of the individual segment identifiers to the plurality of contexts of each of the client nodes.

2. The system of claim 1, wherein the system is programmed to:

3. When the executable code is executed by the one or more processing devices, the one or more processing devices further causing each client node of the plurality of client nodes to map the context of the each client node to each of the respective segment identifiers of the plurality of segment identifiers; 2. The system of claim 1, wherein the mapping is performed by calling a first library function from the library.

4. When the executable code is executed by the one or more processing devices, the one or more processing devices further 4. The system of claim 3, wherein each client node of the plurality of client nodes uses a second library function from the library to request a block of the plurality of segment identifiers assigned to the respective client node.

5. When the executable code is executed by the one or more processing devices, the one or more processing devices further measuring, by each client node of the plurality of client nodes, that a threshold number of the individual segment identifiers of the block of segment identifiers assigned to the each client node have been assigned to the plurality of contexts of the each client node; 2. The system of claim 1, wherein each client node requests an additional block of segment identifiers from the segment identifier manager in response to determining that the number of individual segment identifiers of the block of segment identifiers assigned to each client node assigned to the plurality of contexts of the each client node has reached the threshold.

6. the plurality of client nodes, Intermediate System-to-Intermediate System (IS-IS) protocol; Open Shortest Path First (OSPF) protocol; Border Gateway Protocol (BGP), and static routing, 10. The system of claim 1, wherein the system implements one or more of the following:

7. 2. The system of claim 1, wherein the client nodes implement Segment Routing over Internet Protocol version 6 (SRv6) and use the segment identifiers of the block of segment identifiers based on the SRv6.

8. providing a plurality of client nodes connected to a computer system by a network, said plurality of client nodes implementing a plurality of network protocols; implementing a data plane on the computer system that provides routing of data between the plurality of client nodes and an external network connected to the computer system; receiving, by a segment identifier manager implemented on the computer system, requests for segment identifiers from the plurality of client nodes; assigning, by the segment identifier manager, a block of a plurality of segment identifiers to each client node of the plurality of client nodes in response to a request received from each client node, the plurality of segment identifiers being globally unique among all segment identifiers assigned to the plurality of client nodes; generating a mapping of contexts of the plurality of contexts of each of the client nodes to the respective segment identifiers of the block of the plurality of segment identifiers, the mapping of the contexts of each of the client nodes to the respective segment identifiers being performed by each of the client nodes independent of the segment identifier manager, the mapping of the contexts of each of the client nodes to the respective segment identifiers defining how packets labeled with the respective segment identifiers are routed; periodically transmitting, by each of the client nodes to the segment identifier manager, a mapping of the individual segment identifiers of the plurality of block of segment identifiers to the plurality of contexts of the each of the client nodes; measuring, by each client node of the plurality of client nodes, that a threshold number of the individual segment identifiers of the block of segment identifiers assigned to the each client node have been assigned to the plurality of contexts of the each client node; requesting, by each of the client nodes, from the segment identifier manager, an additional block of segment identifiers in response to determining that the number of individual segment identifiers of the block of segment identifiers assigned to each of the client nodes assigned to the plurality of contexts of the each of the client nodes has reached the threshold; the context for each client node is a forwarding behavior associated with each of the individual segment identifiers; A method comprising:

9. The method further comprises: detecting, by a first client node of the plurality of client nodes, a failure of the first client node; and in response to detecting a failure of the first client node, requesting a mapping of the individual segment identifiers to the plurality of contexts of the first client node from the segment identifier manager.

9. The method of claim 8, comprising:

10. The method further comprises: for each individual segment identifier of the plurality of segment identifiers, mapping the context of each of the client nodes to each of the individual segment identifiers; 9. The method of claim 8, further comprising: mapping each of the individual segment identifiers to the context of each of the client nodes by calling a first library function from a segment identifier management library common to the plurality of client nodes.

11. The method further comprises:

11. The method of claim 10, further comprising: by each client node of the plurality of client nodes, using a second library function from the segment identifier management library to request a block of the plurality of segment identifiers assigned to the each client node.

12. the plurality of client nodes, Intermediate System-to-Intermediate System (IS-IS) protocol; Open Shortest Path First (OSPF) protocol; Border Gateway Protocol (BGP), and static routing, 9. The method of claim 8, wherein the method implements one or more of the following:

13. 9. The method of claim 8, wherein the client nodes implement Segment Routing over Internet Protocol version 6 (SRv6) and use the segment identifiers of the block of segment identifiers based on the SRv6.

Images