Deterministic Networking (DetNet) Controller Plane - VPFC Planning Scheme Based on VPFP in Large-scale Deterministic Networks

4.1.1. Measurement and Calibration

      DetNet transit node A            DetNet transit node B
   +-------------------------+       +------------------------+
   |              Queuing    |       |              Queuing   |
   |   Regulator subsystem   |       |   Regulator subsystem  |
   |   +-+-+-+-+ +-+-+-+-+   |       |   +-+-+-+-+ +-+-+-+-+  |
-->+   | | | | | | | | | +   +------>+   | | | | | | | | | +  +--->
   |   +-+-+-+-+ +-+-+-+-+   |       |   +-+-+-+-+ +-+-+-+-+  |
   |                         |       |                        |
   +-------------------------+       +------------------------+
   |<->|<------>|<------->|<->|<---->|<->|<------>|<------>|<->|<--
2,3  4      5        6      1    2,3   4      5        6     1   2,3
                1: Output delay             4: Processing delay
                2: Link delay               5: Regulation delay
                3: Frame preemption delay   6: Queuing delay

As shown in Figure 7, [RFC9320] highly abstracts the timing model of the DetNet transit node. In a large-scale deterministic network, the implementation of some DetNet transit nodes is a distributed architecture, and the processing delay in these nodes varies widely, which is the operation that contributes the most to the delay jitter. In cycle-based queuing and forwarding, the jitter introduced by various operations needs to be fully considered, so that the end-to-end transmission delay can reach a definite bound.¶

       A
+-----+--------+
|  0  |********|\                       B
+-----+--------+ \               +-----+--------+
|  1  |        |  \              |  0  |        |
+-----+--------+   \             +-----+--------+
|  2  |        |    \            |  1  |        |
+-----+--------+     \           +-----+--------+
|  3  |        |      \          |  2  |********| <-- CTQ
+-----+--------+       \         +-----+--------+
|  4  |        |        \        |  3  |        |\<-- TRQ
+-----+--------+         \       +-----+--------+ \
|  5  |        |          \      |  4  |        |  \
+-----+--------+           \     +-----+--------+   \ <-- JTR
|  6  |        |            \    |  5  |        |  /
+-----+--------+             \   +-----+--------+ /
|  7  |        |              \->|  6  |********|/<-- SRQ
+-----+--------+                 +-----+--------+
                                 |  7  |        |
                                 +-----+--------+

CTQ : Current transmitting queue when the packet arrives
TRQ : Theoretical receiving queue for the packet
SRQ : Safe receiving queue for the packet
JTR : Jitter of the node

Taking CSQF as an example, before forwarding, it is necessary to establish a mapping relationship between the scheduling cycles of the outgoing interfaces of upstream and downstream nodes, and the process is completed by measurement and calibration. (In order to simplify the description, the specific interface of the Node A is uniformly replaced by the Node A, and similar for Node B.)¶

As shown in Figure 8, taking 8 cycles as an example, Node A and Node B are two adjecent CSQF nodes. Node A is the upstream node, and Node B is the downstream node. To know which cycle is being scheduled in Node B (for example, cycle 2 in Figure 8) when packets sent from a certain cycle in Node A (for example, cycle 0 in Figure 8) reaches it, a measurement should be applied. The specific implementation of the measurement is beyond the scope of this demo, and will not be described here. After the measurement is done, the forwarding cycle in Node B for these packets should be decided, which should take into account the processing delay variant in the device. In this example, for packets sent in cycle 0 of Node A, cycle 6 is chosen as forwarding cycle in Node B. The packets sent in cycle 1 of Node A are assigned to cycle 7 of Node B, and so on. This is the task to be done by calibration.¶

After calibration, the scheduling cycles of A and that of B have the following mapping relationship:¶

0 --> 6
1 --> 7
2 --> 0
3 --> 1
4 --> 2
5 --> 3
6 --> 4
7 --> 5.¶

In terms of jitter absorption in Figure 8, it is feasible to assign the packet sent in the 0th scheduling cycle of Node A to the queue in the 6th or 7th or 0th scheduling cycle of Node B. So there is more than one mapping that can be calibrated.¶

4.1.2. Mapping Function and Scheduling Cycle Conflict Resolution

As described in Section 4.1.1, after the calibration is completed, a definite mapping relationship is established between the scheduling cycles of the outbound interface of the two adjacent nodes. This relationship can be regarded as a function f: its domain is the scheduling cycle range of Node A, 0~7, and its range is the scheduling cycle range of Node B, 0~7. Further constraint can be imposed on the mapping relationship: during calibration, any scheduling cycle in A has one and only one scheduling cycle in B which is calibrated with it. Under this constraint, the function f becomes an injective function.¶

 [1]>> +-----+ [1]>>
-------| PE1 |------
       +-----+  f1  \
                     \
                      \
                       \
                        \      f2
 [2]>> +-----+ [2]>>  +-----+ [1]>>
-------| PE2 |--------| P1  |------
       +-----+  g1    +-----+ [2]>>\
                               g2   \
                                     \
                                      \      [1]>>
                                       \     [2]>>
 [3]>> +-----+ [3]>>  +-----+ [3]>>  +-----+ [3]>>  +-----+
-------| PE3 |--------| P2  |--------| P3  |--------| P4  |
       +-----+  h1    +-----+  h2    +-----+        +-----+

[N] : Flow N
 >  : Direction of flows
fN/gN/hN : Mapping functions

The cycle planning is further constrained: in the same CSQF domain, all interface plan the same number of scheduling cycles. Under this constraint, all mapping functions have the same domain and range.¶

Note:Different interfaces of the same node can belong to different domains, and the cross-domain processing is beyond the scope of this document.¶

It is assumed that the calibrated mapping between the scheduling cycles of the outbound interfaces of the upstream and downstream nodes described in Figure 9 also satisfies the injective function relationship, and the calibrated relationship between the scheduling cycles of the outbound interfaces of PE1 and P1 is the functional relationship f1, and the calibrated mapping relationship between the scheduling cycles of the outbound interfaces of P1 and P3 is the functional relationship f2. The mapping relationship between the PE and the scheduling cycles of the P3 outbound interface satisfies the composite function f:¶

• f = f2(f1)¶

According to the property of injective function, f is also an injective function.¶

Similarly, we can get:¶

• g = g2(g1)
  h = h2(h1)¶

and g, h are both injective functions, where g2 is the mapping relationship between the scheduling cycle of outbound interface of P1 and the scheduling cycle of outbound interface of P3, and h2 is the mapping relationship between the scheduling cycle of outbound interface of P2 and the scheduling cycle of outbound interface of P3.¶

With the above constraints,assume the flow from PE1, PE2, and PE3 conflicts at P3, that is, they are mapped to the same scheduling cycle. Let the scheduling cycles of flow in PE1, PE2, and PE3 be a, b, and c respectively, the following situation occurs:¶

The function values of f(a), g(b) and h(c) appear the same, which is a conflict. According to the property of the injective function, if a is changed to d (d!= a), then f(d) != f(a), so f(d) != g(b) and f(d) != h(c). Similarly, changing the input of function g or h can also achieve the effect of eliminating conflict.¶

At the same time, it is easy to draw the following conclusions:¶

For f = f2(f1), if d != a, then f(d) != f(a) and f1(d) != f1(a).¶

Further generalize this conclusion: Suppose that the ordered set <f1, f2, ..., fn> is a set composed of injective functions(where n is a natural number), and the domain and range are both A, A={x|0<=x<k , x and k are natural numbers}. The composite function composed of the first i (1<=i<=n) functions is denoted as:¶

• f[i] = fi(fi-1(...(f1))).¶

Let the proper subsets B and C of set A satisfy the condition:¶

The union of B and C is A, the intersection of B and C is empty set, then for any b in B and any c in C, f[i](b) != f[i](c).¶

When planning the usage of scheduling cycles, the scheduling cycles that have been traversed in the scheduling cycles of the head node of VPFP (e.g., Ingress PE) are regarded as set B, and the scheduling cycles that have not been traversed are regarded as set C. When a conflict for a scheduling cycle occurs when converging with other paths, a new scheduling cycle c is selected from C, and the new c and the set elements that have been traversed in set B as input produce different results. That is, there will be no cycle planning conflicts starting from the same head node along the currently planning VPFP. In this way, it is only necessary to judge whether there is a conflict with other path aggregation, and if there is no conflict, the scheduling cycle planning is successful.¶

Note: When there are multiple mapping relationships that can be calibrated, each calibrated relationship corresponds to a function. In multiple planning, different function mappings can be used each time.¶

4.1.3. Proposed Resources Planning Scheme

Under the prerequisite of rational utilization of resources,the key issue to ensure that the theoretical conditions of CSQF are satisfied is to plan a VPFC to be scheduled during a certain cycle of the interface of the corresponding node. In other words, the forwarding capability corresponding to the specified cycle interval on the interface of the corresponding node is allocated to the VPFC. The common feature of cycle-based forwarding is that all data is first buffered and then forwarded in a specific cycle interval. Combined with this feature, the more abstract forwarding capability during a cycle can be converted into the cache resources required for the specific data that can be forwarded during this cycle. The problem is transformed into a buffer resources reservation problem, that is, the buffer resources is reserved for the deterministic flows that are allowed to be scheduled during the cycle (referred to as resources reservation for cyclic forwarding), and the deterministic flows that do not have buffer resources reserved are not scheduled during the cycle.¶

According to the conclusion in Section 4.1.2, the resources in the CSQF domain can be reasonably planned. When a scheduling cycle conflict occurs on the convergence point or the outbound interface with small bandwidth and the traffic entering from other paths, change the planning cycle of the head node, then perform cycle calculation along the VPFP and try to reserve resources. After the attempt is successful, the conflict can be eliminated.¶

At the same time, because the mapping functions along the VPFP are injection functions, we can regard the scheduling cycle and buffering resources of the non-head node's aggregation interface or low-bandwidth outbound interface to be shared as a common resources, and allocate this common resources to the head nodes with deterministic transmission requirements. The resources allocated on the head node and the VPFP constitute the VPFC of our scheme.¶

The injective function also strictly constrains the corresponding relationship between the head node and convergent node resources. Therefore, the head node only needs to save the allocated resources of its own node, and does not need to save the allocated resources of the non-head node (including sink node). The non-head node does not need to save the resources allocation state, and the resources allocation state is saved by the MCPE, so as to achieve the lightweight implementation of the resources reservation of the non-head node (e.g., P node).¶

While the head node of VPFP performs VPFC scheduling strictly according to the resources allocated to the VPFC, conflicts can be avoided on the non-head node's aggregation interface or low-bandwidth outbound interface sharing transmission. Scheduling strictly according to allocated resources on the head node is a key issue, which will be further studied in other literatures.¶

According to [RFC8655], service flows can be aggregated and resources can be reserved for the aggregated flows. With our solution, the aggregated flows share the scheduled resources reserved on the edge nodes, and the resources competition is localized. The delay jitter caused by the aggregated flows will also be local, and it is easier to realize the time delay bounded. In order to further optimize the jitter of the member service flows in the aggregate flow, only the scheduling resources allocated to the edge nodes of the aggregate flow need to be further refined, and this arrangement will not cause the change of global resources allocation.¶

By separating resources planning from measurement and calibration, there is no need to consider the problem of path aggregation when performing calibration after measurement, which can greatly reduce the complexity of calibration.¶

4.2.1. Establish New resources Metrics

Forwarding resources are a relatively vague concept. They include not only bandwidth resources, but also device storage resources. For example, high-speed on-chip caches inside ASICs are often measured in units of bytes rather than bps. It is not enough to consider bandwidth only when reserving resources, we have to establish a new resources metric in bytes or bytes of a certain length, for example, 64 bytes is one resources unit. The comprehensive capability of one cycle is measured in new resources units, which covers cache capacity, cycle interval time, and interface bandwidth. In this way, the three dimensions of cycle duration, cache capacity, and physical bandwidth are simplified into one dimension: the number of resources units, so as to simplify the implementation of resources reservation.¶

For example, assuming that the backbone network is uniformly divided into a 10us scheduling cycle and one resources unit has 64 bytes, the data that can be transmitted on a 400G interface in each scheduling cycle is about 7812 resources units, 1953 on a 100G interface, 195 on a 10G interface, and 19 on a 1G interface. The amount of resources that can be provided by the scheduling cycle of an interface is given by the comprehensive evaluation of the implementation specifications of devices such as interface bandwidth and storage resources. Resources planning is done based on this quantity, which simplifies implementation.¶

4.2.2. Resources Reservation Corresponding to the Scheduling Cycle

 [1]>> +-----+ [1]>>
-------| PE1 |------
       +-----+      \
                     \
                      \
                       \
                        \
 [2]>> +-----+ [2]>>  +-----+ [1]>>
-------| PE2 |--------| P1  |------
       +-----+        +-----+ [2]>>\
                                    \
                                     \
                                      \      [1]>>
                                       \     [2]>>
 [3]>> +-----+ [3]>>  +-----+ [3]>>  +-----+ [3]>>  +-----+
-------| PE3 |--------| P2  |--------| P3  |--------| P4  |
       +-----+        +-----+        +-----+        +-----+


Resourc of the interfaces:

                 T=10us      Buffers
            +-----+        +--------+
          / |  T  | =====> |   1    |
          | +-----+        +--------+
          | |  T  |        |   1    |
N cycles <  +-----+        +--------+
          | | ... |        |  ...   |
          | +-----+        +--------+
          \ |  T  |        |  1953  |
            +-----+        +--------+

[N] : Flow N
 >  : Direction of flows

This section extends the description of the method described in Section 4.1 in conjunction with the constraints of Section 4.2.1.¶

According to the theory in Section 4.1, if the scheduling cycle a of PE1 is mapped to the scheduling cycle c of P1, and the scheduling cycle b of PE2 is also mapped to the scheduling cycle c of P1, then a cycle conflict occurs. The conflict can be resolved by adjusting the scheduling cycle a or b, but if P1 has multiple units of resources in the same scheduling cycle, it is allowed to allocate resources in the same scheduling cycle to PE1 and PE2 as needed, thereby increasing the utilization of resources in the scheduling cycle.¶

Based on the resources metrics proposed in Section 4.2.1, the resources of the scheduling cycle are uniformly quantified. As shown in Figure 10, assuming the data rates of all physical links are 100Gbps, and the length of the scheduling cycle is 10us, each scheduling cycle can transmit 1953 64-byte data resources units. Because of multiple resources belonging to one cycle, instead of explicitly judging whether a scheduling cycle conflict occurs, it is changed to judge whether the resources corresponding to the scheduling cycle on the path meet the demand. If the demand for resources can be satisfied, the corresponding resources are reserved. Otherwise, the MCPE chooses another scheduling cycle as the input of the function, and tries iterative calculation and resources reservation again.¶

According to the resources demand of a DetNet flow, starting from the head node of the VPFP, the functions in the path are sequentially called along the VPFP for calculation. Firstly, the first value in the domain of the function associated with the head node, is used as the input of that function, and then the previous function's value is used as the input value of the next function for iterative calculation. Concomitantly, it is judged whether the resources of the cycle corresponding to each input value and output value meet the demand. If the resources do not meet the demand, the current iterative calculation is terminated, and the next value in the domain of the function associated with the head node is used as a new input, and the above processing is continued. When all the values in the domain of the function of the head node are traversed and fail to meet the demand, no VPFC is successfully planned for the DetNet flow. If the resources meets the demand, a VPFC is successfully planned, and the remaining resources corresponding to the scheduling cycle are updated along the planned VPFC. The controller plane records the VPFC, and delivers the VPFC to the head node of the VPFP.¶

To optimize resources usage, multiple DetNet flows can be aggregated together to share a VPFC. For example, suppose the cycle duration is 10us and 10 cycles are used, then each cycle will be scheduled once every 100us. If 1 unit of resources is allocated to a VPFC for a DetNet flow which sends 1 unit of data every 1ms, then only 1/10 of the allocated resources is really used. If another DetNet flow regularly sends 1 unit of data every 3ms, which has the same forwarding path with the VPFC, then this VPFC can be shared. Of course, this inevitably introduces jitter, but this jitter is bounded, unperceived or tolerated by most applications, and can be eliminated by other methods, which are beyond the scope of this document.¶

4.2.3. Resources of Scheduling Cycle Description

Scheduling cycle resources description:¶

(node, interface, scheduling cycle): (number of available resources, number of initial resources), where the number of resources is measured in uniform resources units. For example, in Figure 10, assuming that the total number of cycles in the domain is uniformed as 8, the cycle interval is 10us, the PE1's Intf0 is a 10Gbps interface, and each cycle can forward about 193 units of resources. For factors that have not been considered, some capabilities need to be reserved, the number of resources can be initialized as 180. The resources numbers of PE1's Intf0 are initialized as follows:¶

(PE1,Intf0,Cycle0): (180,180);
(PE1,Intf0,Cycle1): (180,180);
(PE1,Intf0,Cycle2): (180,180);
(PE1,Intf0,Cycle3): (180,180);
(PE1,Intf0,Cycle4): (180,180);
(PE1,Intf0,Cycle5): (180,180);
(PE1,Intf0,Cycle6): (180,180);
(PE1,Intf0,Cycle7): (180,180);¶

The P1's Intf3 is a 100Gbps interface, and each cycle can forward about 1953 units of resources. For factors that have not been considered, some capabilities need to be reserved, the number of resources can be initialized as 1900. The resources numbers of P1's Intf3 are initialized as follows:¶

(P1,Intf3,Cycle0): (1900, 1900);
(P1,Intf3,Cycle1): (1900, 1900);
(P1,Intf3,Cycle2): (1900, 1900);
(P1,Intf3,Cycle3): (1900, 1900);
(P1,Intf3,Cycle4): (1900, 1900);
(P1,Intf3,Cycle5): (1900, 1900);
(P1,Intf3,Cycle6): (1900, 1900);
(P1,Intf3,Cycle7): (1900, 1900);
¶

The controller plane maintains the resources information of the scheduling cycle of the interface of each node, and reduces the number of available resources in the corresponding scheduling cycle of the interface of the corresponding node after the DetNet flow path resources reservation is performed.¶

4.2.4. Mapping Function

Assuming that each node is divided into n equal-length scheduling cycles, after measurement and calibration, there are n function mapping relationships:¶

y = (x+k) mod n, the domain of definition is {x | 0<=x<n, x and n are natural numbers}, and the value range of the constant k is: {k | 0<=k<n, k and n are natural numbers, n>3}, (In principle, the scheduling cycle and the number of corresponding CSQF queues can be less than 3, but in large-scale deterministic networks, it is unrealistic to be less than or equal to 3, and it is not conducive to resources planning).¶

Taking the network in Figure 9 as an example, it is assumed that each node is divided into 8 (n=8) equal-length scheduling cycles. After measurement, the function mapping relationships such as f1~2, g1~2, and h1~2 are obtained by calibration as one of the following 8 functions:¶

y = (x+0) mod 8, {x | 0<=x<8, x is a natural number};
y = (x+1) mod 8, {x | 0<=x<8, x is a natural number};
y = (x+2) mod 8, {x | 0<=x<8, x is a natural number};
y = (x+3) mod 8, {x | 0<=x<8, x is a natural number};
y = (x+4) mod 8, {x | 0<=x<8, x is a natural number};
y = (x+5) mod 8, {x | 0<=x<8, x is a natural number};
y = (x+6) mod 8, {x | 0<=x<8, x is a natural number};
y = (x+7) mod 8, {x | 0<=x<8, x is a natural number};¶

As a specific example,these functions can be finally decided as:¶

f1(x) = (x+3) mod 8, {x | 0<=x<8, x is a natural number};
f2(x) = (x+1) mod 8, {x | 0<=x<8, x is a natural number};
g1(x) = (x+4) mod 8, {x | 0<=x<8, x is a natural number};
g2(x) = (x+5) mod 8, {x | 0<=x<8, x is a natural number};
h1(x) = (x+6) mod 8, {x | 0<=x<8, x is a natural number};
h2(x) = (x+7) mod 8, {x | 0<=x<8, x is a natural number};¶

The controller plane saves the mapping function which is one of the components used to describe VPFP.¶

4.2.5. Resources Demand

The resources demand here is the input for reservation processing after conversion processing of app-flow's requirements (see [RFC9016]), not the original transmission requirement of an app-flow.¶

Resources demands are described as a list of requirements:¶

{sub-demand 1, sub-demand 2, ...}¶

Each sub-demand looks like:¶

(Virtual Periodic Forwarding Path): (Outbound Interface, Scheduling Cycle, Number of Resources Units Required, Minimum Allocation Granularity Per Cycle).¶

The components of the above requirements are described as follows:¶

• "Virtual Periodic Forwarding Path" is used to specify the virtual periodic forwarding path for allocating resources;¶
• "Outbound Interface" is the outgoing interface of the first node in the virtual periodic forwarding path;¶
• "Scheduling Cycle" is used to specify which cycle to be selected in the first node to send data. The resources of the cycle need to be allocated. The scheduling cycle may not be specified, indicating that any cycle can be used. Otherwise, the resources are allocated according to the specified cycle;¶
• "Number of Resources Units Required" is used to specify the number of resources required by the resources requirement;¶
• "Minimum Allocation Granularity per Cycle" specifies the minimum number of resources allocated in the same scheduling cycle to ensure that the same data packet of a deterministic service flow does not cross the scheduling cycles. For example, if each packet transmission of a service flow requires 2 resources units, then the "Minimum Allocation Granularity per Cycle" will be 2, means at least 2 resources units needs to be allocated from the same scheduling cycle.¶

For the transmission requirements of app-flows with strict jitter upper bound requirements, resources for a specified cycle may be allocated. For example, a certain DetNet flow has a transmission requirement of one resources unit, but it is required to be transmitted in time, and the jitter is less than 2 scheduling cycles. CSQF can meet this requirement. A unit of resources is allocated from each cycle along the VPFP, so that no matter when the data of the service flow arrives, there is always a unit of resources is ready.¶

In order to facilitate the following description, the demand list is further symbolized, and the resources demand is described as the demand list DemandList:¶

{SubDemand1, SubDemand2, ...}¶

SubDemand for each specified cycle is in the form of:¶

(VPFP): (oif,cycle,res,min);¶

That is, SubDemand1 is set to "(VPFP): (oif1, cycle1, res1, min1)".¶

The allocation of sub-requirements for each non-specified cycle is as follows:¶

(VPFP): (oif, InvalidCycle, res, min);¶

That is, SubDemand1 is set to "(VPFP): (oif1, InvalidCycle, res1, min1)".¶

where VPFP is described in Section 3.1, for example, VPFP is:¶

(PE1,Intf0) f1 (P1,Intf3) f2 (P3,Intf3) f3 (P4,Intf2) f4 (PE5,Intf0)¶

For example, for a flow, its path is the above VPFP, and for its specified cycle allocation, its resources demand list DemandList on PE1 can be expressed as:¶

{
(VPFP): (intf0,Cycle0,1,1),
(VPFP): (intf0,Cycle1,1,1),
(VPFP): (intf0,Cycle2,1,1),
(VPFP): (intf0,Cycle3,1,1),
(VPFP): (intf0,Cycle4,1,1),
(VPFP): (intf0,Cycle5,1,1),
(VPFP): (intf0,Cycle6,1,1),
(VPFP): (intf0,Cycle7,1,1)
}¶

The above allocation indicates that resources of 0 to 7 cycles are allocated to the flow, and one unit of resources is allocated from each cycle; and if the resources list DemandList allocated by the scheduling cycle is not specified, it can be expressed as:¶

{(VPFP): (intf0, InvalidCycle, 10, 2)}, where InvalidCycle is the invalid cycle, defined by the implementation.¶

4.2.7. Resources Reservation Results

The resources allocation result of the specified scheduling cycle is exactly the same as the resources allocation result of the non-specified cycle, and it is described as a result list:¶

{subresult 1, subresult 2, ...}¶

Each sub-result looks like:¶

(path information): (outbound interface, scheduling cycle, number of resources units).¶

In order to facilitate the following description, the resources allocation result list is further symbolized, and the resources allocation result is the result list ResultList:¶

{SubResult1,SubResult2, ...}¶

SubResult of each specified cycle sub-requirement is as follows:¶

(VPFP): (oif, cycle, res);¶

That is, SubResult1 is set to (VPFP): (oif1, cycle1, res1).¶

Where VPFP is described in Section 3.3, for example:¶

VPFP is:¶

(PE1,Intf0) f1 (P1,Intf3) f2 (P3,Intf3) f3 (P4,Intf2) f4 (PE5,Intf0)¶

List of results after the specified cycle reservation method is successful:¶

{
(VPFP): (intf0,Cycle0,1),
(VPFP): (intf0,Cycle1,1),
(VPFP): (intf0,Cycle2,1),
(VPFP): (intf0,Cycle3,1),
(VPFP): (intf0,Cycle4,1),
(VPFP): (intf0,Cycle5,1),
(VPFP): (intf0,Cycle6,1),
(VPFP): (intf0,Cycle7,1),
}¶

After the reservation of non-specified cycle resources is successful, the resulting list contains the actually reserved cycles and their corresponding resources. Suppose the requirements of Flow1 are as follows:¶

{(VPFP): (intf0, InvalidCycle, 10, 2)}¶

After the allocation is successful, the result list may be:¶

{(VPFP): (intf0,Cycle0,10)}¶

It may also be as follows, when one cycle cannot meet the transmission demand, it is allocated from multiple cycles:¶

{
(VPFP): (intf0, Cycle0, 5),
(VPFP): (intf0, Cycle1, 5)
}¶

Note: When resources requirements are allocated for multiple scheduling cycles, ensure that the resources allocated for each cycle can transmit the full packet in service.¶

After the resources is successfully reserved, the MCPE needs to record the VPFC planned for the DetNet flow, which will be used for the reasons of VPFC recycling, modifying, etc. Since the topology may change, resources reclamation cannot rely on topology information. Therefore, it is necessary to save the VPFC allocated on the PE on the controller plane.¶

5.2.1. Reservation Calculation for Resources with Specified Cycle

Assuming the format of the path information calculated by MCPE is as described in Section 3.1, then VPFP1 is:¶

(PE1,Intf0) f1 (P1,Intf3) f2 (P3,Intf3) f3 (P4,Intf2) f4 (PE5,Intf0)¶

The resources demand list for specified cycle is:¶

{
(VPFP1): (intf0,Cycle0,1,1),
(VPFP1): (intf0,Cycle1,1,1),
(VPFP1): (intf0,Cycle2,1,1),
(VPFP1): (intf0,Cycle3,1,1),
(VPFP1): (intf0,Cycle4,1,1),
(VPFP1): (intf0,Cycle5,1,1),
(VPFP1): (intf0,Cycle6,1,1),
(VPFP1): (intf0,Cycle7,1,1)
}¶

For the convenience, the node, outgoing interface, and available resources are respectively abbreviated as cn (Current Node), ci, and ar. So cn.ci.ar[c] denotes the available resources in cycle c of the outgoing interface of current node. For the above resources demands for specified scheduling cycle, perform the following resources reservation calculation and reservation processing:¶

1. Let SubDemand be the first entry(sub-demand) of DemandList. The format of SubDemand is: (VPFP):(oif,cycle,res,min); Go to 2);¶
2. Get VPFP from SubDemand. Let IngressPE be the first node in VPFP, and EgressPE be the last node in VPFP. Let cn be IngressPE. Variant j keeps the value of the current node's scheduling cycle, let j=cycle. Go to 3);¶
3. If cn.ci.ar[j] >= res, it indicates that the available resources in the current scheduling cycle meet the resources demand, go to 4); otherwise, the reservation fails, go to 8);¶
4. If cn is the EgressPE of VPFP, then the resources reservation of the entire VPFP for SubDemand completed. Save the result to ResultList, then go to 5); otherwise, go to 6);¶
5. If SubDemand is the last entry in DemandList, it indicates that all sub-demands have been satisfied, then go to 7); Otherwise, let SubDemand be the next entry in DemandList, then go to 2);¶
6. From VPFP, get the mapping function fx between cn.ci and the outgoing interface of the next node. Then update cn, let it be the next node in VPFP, and cn.ci is the corresponding outgoing interface. Calculate the scheduling cycle for the outgoing interface of the next node, and update the value of j. That is, let j=fx(j). Go to 3);¶
7. The resources reservation calculation succeed, and the resources reservation will be performed. For details, see Section 5.2.3.¶
8. The resources reservation calculation fails, the ResultList should be recycled. For details, see the overall process at the beginning of Section 5.2.¶

5.2.2. Reservation Calculation for Resources with Non-Specified Cycle

Assuming the format of the path calculated by MCPE is as described in Section 3.1, and VPFP1 is:¶

(PE1,Intf0) f1 (P1,Intf3) f2 (P3,Intf3) f3 (P4,Intf2) f4 (PE5,Intf0),¶

and VPFP2 is:¶

(PE2,Intf0) g1 (P1,intf3) f2 (P3,intf3) f3 (P4,intf2) f5 (PE5,Intf1)¶

The resources demand list for unspecified cycle is:¶

{
(VPFP1): (intf0, InvalidCycle, 10,2);
(VPFP2): (intf0, InvalidCycle, 8,2)
},¶

Where InvalidCycle means invalid cycle, whose value is defined by the implementation.¶

For the above resources demands for non-specified scheduling cycle, perform the following resources reservation calculation and reservation processing:¶

1. Let SubDemand be the first sub-demand entry of DemandList. The format of SubDemand is: (VPFP): (oif,cycle,res,min). Go to 2);¶
2. Get VPFP from SubDemand. Let IngressPE be the first node in VPFP, and EgressPE be the last node in VPFP. Let cn be IngressPE. Some variants are defined: j keeps the value of the current node's scheduling cycle; c keeps the value of the scheduling cycle in IngressPE; Demand keeps the number of resources to be reserved; CandDemandRes keeps the number of candidate demand resources corresponding to cycle j. The search starts from the cycle 0 in IngressPE, so the initial values are : cn=IngressPE; c=j=0; SubDemandRes=res; CandDemandRes=SubDemandRes; Go to 3);¶
3. If cn.ci.ar[j] >= CandDemandRes, it indicates that the available resources of the current scheduling cycle meet the resources demand SubDemandRes. Let j=c, go to 4); otherwise, go to 8);¶
4. If cn is the EgressPE of VPFP, It indicates that the available resources of all scheduling cycles along the VPFP corresponding to the scheduling cycle c of the head node meet the resources demand CandDemandRes, then go to 5); otherwise, go to 6);¶
5. Record the SubResult currently calculated, where SubResult is (VPFP): (oif, c, CandDemandRes), add SubResult to the result-list ResultList, go to 7);¶
6. From VPFP, get the mapping function fx between cn.ci and the outgoing interface of the next node. Then update cn, let it be the next node in VPFP, and cn.ci is the corresponding outgoing interface. Calculate the scheduling cycle for the outgoing interface of the next node, and update the value of j. That is, let j=fx(j). Go to 3);¶
7. If CandDemandRes >= SubDemandRes, it indicates that the remaining resources demand of SubDemand is met, go to 8); otherwise, go to 10) ;¶
8. If SubDemand is the last entry in DemandList, it indicates that all sub-demands have been satisfied, then go to step 19); otherwise, go to 9);¶
9. Let SubDemand be the next entry in DemandList, then go to 2);¶
10. If c<cycles-1, which means c is not the last scheduling cycle, go to 11); otherwise, it means all cycles of IngressPE have been traversed, but the resources demands cannot be met, go to step 20);¶
11. Let SubDemandRes = SubDemandRes - CandDemandRes. Go to 12);¶
12. If SubDemandRes<min, It indicates that the remaining resources demand is less than the minimum allocation granularity, then go to 13); otherwise, go to 14);¶
13. Let SubDemandRes=min, which updates the remaining resources demand as the minimum allocation granularity; go to 14);¶
14. Prepare for the next scheduling cycle of IngressPE to be processed. Let CandDemandRes=SubDemandRes, c=c+1, j=c, cn=IngressPE. Go to step 3);¶
15. If c<cycles-1, which means c is not the last scheduling cycle, then go to 16); otherwise, it means all cycles of IngressPE have been traversed, but the resources demands cannot be met, go to step 20);¶
16. Let k=floor(cn.ci.ar[j]/min), where min is the minimum allocation granularity. Go to 17);¶
17. If k>0, it indicates that the available resources of the current scheduling cycle of the current node meet part of the resources demand, then go to 18); otherwise go to 14);¶
18. Let CandDemandRes=k*min, go to 4);¶
19. The resources reservation calculation succeeds, and the resources reservation will be performed. For details, see Section 5.2.3.¶
20. The resources reservation calculation fails, release the resources in the ResultList. For failure handling, see the overall process at the beginning of Section 5.2.¶

5.2.3. Execution of Cycle Resources Reservation

After the resources reservation calculation, the resources reservation is executed. The MCPE traverse the ResultList and perform the following resources reservation operations:¶

1. Let SubResult be the first entry in ResultList. The format of SubResult is: (VPFP): (oif, cycle, res). Go to 2);¶
2. Get VPFP from SubResult. Let IngressPE be the first node in VPFP, and EgressPE be the last node in VPFP. Let cn be IngressPE. Let j be the current cycle, so j=cycle. Go to 3);¶
3. Update the resources of the cycle j, that is, the number of resources of cn.ci.ar[j] is reduced by res. See Section 4.2.3 for the description of the resources of the cycle. Go to 4);¶
4. If cn is the EgressPE of VPFP, then the resources reservation of the entire VPFP completed, go to 5); otherwise, go to 6);¶
5. If SubResult is the last entry in ResultList, then the reservation is completed for all sub-results, go to 7); otherwise, let SubResult be the next entry in ResultList, go to 2);¶
6. From VPFP, get the mapping function fx between cn.ci and the outgoing interface of the next node. Then update cn, let it be the next node in VPFP, and cn.ci is the corresponding outgoing interface. Calculate the cycle for the outgoing interface of the next node, and update the value of j. That is, let j=fx(j). Go to 4);¶
7. Save ResultList to the database, then return success.¶