Service Function Chaining with Deterministic Fault Tolerance in Optical Edge Networks

—In the upcoming 5G-and-beyond era, ultra-reliable low-latency communication (URLLC) services will be ubiquitous in edge networks. To improve network performance and quality of service (QoS), URLLC services could be delivered via a sequence of software-based network functions, also known as service function chains (SFCs). Towards reliable SFC delivery, it is imperative to incorporate deterministic fault tolerance during SFC deployment. However, deploying an SFC with deterministic fault tolerance is challenging because the protection mechanism needs to consider protection against physical/virtual network failures and hardware/software failures jointly. Against multiple and diverse failures, this work investigates how to effectively deliver an SFC in optical edge networks with deterministic fault tolerance while minimizing wavelength resource consumption. We introduce a protection augmented graph, called k -connected service function slices layered graph (KC-SLG), protecting against k -1 fiber link failures and k -1 server failures. We formulate a novel problem called deterministic-fault-tolerant SFC embedding and propose an effective algorithm, called most candidate first SF slices layered graph embedding (MCF-SE). MCF-SE employs two proposed techniques: k -connected network slicing (KC-NS) and k connected function slicing (KC-FS). Through thorough mathematical proof, we show that KC-NS is 2 -approximate. For KC-FS, we demonstrate that k = 3 provides the best cost-efficiency. Our experimental results also show that the proposed MCF-SE achieves deterministic-fault-tolerant service delivery and performs better than the schemes directly extended from existing work regarding survivability and average cost-efficiency.


I. INTRODUCTION
ITH the increasing deployment of 5G infrastructure, many edge servers are fiber-connected to provide ultrareliable low-latency communication (URLLC) services for clients at the network edge [1]. With densely-connected edge servers, a service provider can enable ubiquitous access and agile provisioning while satisfying the required quality of service (QoS) for URLLC services. Traditionally, URLLC traffic traverses a sequence of middleboxes providing various functions (e.g., firewall, load balancer, etc.) [2]. However, these proprietary middleboxes only support dedicated functions and are expensive to maintain and manage [3]. Recently, network function virtualization (NFV) is introduced to avoid dedicated middleboxes and facilitate agile service provisioning by converting the traditional hardware-based network functions into software-based modules, called service functions (SFs) [4]. In the NFV paradigm, SFs run on commodity/edge servers to process clients' data [5]. A client's network service request (NSR) generally demands a set of SFs and related resources (e.g., computing resources, bandwidth, virtual machines, etc.). To accommodate an NSR, the service provider can concatenate the demanded SFs into a service function chain (SFC) and embed it onto a shared physical network (PN). Specifically, a virtual machine that runs a specific SF is called an SF instance. The physical node that hosts an SF instance is called this SF's physical candidate, while the physical forwarding path for an SFC is called a service function path (SFP). The process of accommodating an NSR in a shared PN is referred to as service function chaining and embedding (SFCE) [6].
In 5G-and-beyond networks, strict fault tolerance is necessary for applications requiring strict QoS requirements such as intelligent transportation systems, smart manufacturing systems, and remote surgery, where a network interruption can cause a significant financial loss or casualty [7]- [10]. Delivering SFCs in such applications needs to provide fault tolerance against failures of both physical component (e.g., node or link) and software (e.g., SF instance). Most existing research concentrated on fault tolerance of a network [11]- [19], but few works have focused on fault-tolerant mechanisms of the SFC delivery [20]- [23]. In [22], two disjoint SFPs (primary and backup) are established to tolerate a single node, link, or SF instance failure. In [23], an SFP fault-tolerant mechanism is proposed to handle multiple SF instance failures. However, when delivering SFCs, these approaches cannot handle the coincidence of multiple and diverse failures (e.g., node/link failures and SF instance failures).
With ultra-reliability and fast transmission speed, the optical network is promising for reliable data transmission in edge computing systems [35]. The optical edge network (OEN) is generally deployed at an industrial park and carries many SFPs. Due to various service level agreements or different QoS requirements, SFPs need to be configured at different faulttolerant levels. Here, the fault-tolerant level is correlated to the number of failures (including physical component and SF instance failures) that an ongoing SFP can simultaneously tolerate. In practice, delivering an SFC for applications with strict QoS demands requires a higher fault-tolerant level than regular applications. For example, an SFP for a remote surgery may need a higher fault-tolerant level than an SFP for cloud gaming. Meanwhile, a higher fault-tolerant level is at the In this work, we investigate how to effectively deliver an SFC in the OEN with deterministic fault tolerance. We define a new problem called deterministic-fault-tolerant SFC embedding (DFT-SFCE), which tries to satisfy a service request using a k-fault-tolerant SFP while minimizing wavelength resource consumption. We first introduce an augmented graph, called k-connected SF slices layered graph (KC-SLG). Based on such a KC-SLG, we propose an efficient heuristic algorithm, called most candidate first SF slices layered graph embedding (MCF-SE), which comprises two major processes: k-connected network slicing (KC-NS) and k-connected function slicing (KC-FS). We prove that KC-NS is 2-approximate and verify its 2-approximate performance with experimental results. When investigating the impact of k values in KC-FS, we find that (1) k = 3 can achieve the best cost-protection ratio (i.e., wavelength resource consumption divided by k), and (2) k = 3 has the best average cost-survivability ratio (i.e., wavelength resource consumption divided by the survivability of the deployed services, where the survivability is the ratio between the number of survived services after failures and the total number of deployed services). Moreover, compared to the schemes directly extended from the existing works [22] [23], the proposed MCF-SE algorithm has a better survivability and a higher average cost-survivability ratio.
The rest of this paper is organized as follows. Section II summarizes the related work. Section III introduces the kconnected SF slices layered graph. We formulate the problem of deterministic-fault-tolerant SFC embedding (DFT-SFCE) in Section IV. Sections V and VI analyze the NP-hardness of DFT-SFCE, and present algorithms to solve the problem under various network scenarios. Section VII shows and analyzes experimental results. Section VIII concludes the paper.

II. RELATED WORK
With increasingly-deployed 5G infrastructures, ubiquitous access, low latency, and reliable communication become essential for delivering clients' services. In the literature, significant efforts have been put into investigating fault-tolerant mechanisms for providing reliable communications [11]- [23]. In Fig. 1, we broadly classify the existing work on network failures as: (1) one-type failure or (2) mixed-type failure. The works on "one-type failure" consider the same type of failure (i.e., either node failure, link failure, software failure, etc.), while the works on "mixed-types failure" take failures of diverse types into account. Moreover, in Fig. 1, the "single failure" represents that one failure is fixed before the subsequent failure occurs, while the term "multiple failures" means that multiple failures may coincide.
Single and One-Type Failure: Many works have been done to protect the network from a single and one-type failure [12][13] [15] [21]. In [12], the authors proposed a scheme that finds the most efficient backup path to protect the service from single link failure with the group table-based re-routing technique. The authors in [13] exploited bandwidth squeezing and survivable multi-path provisioning to protect a 5G network slice from single fiber failure while minimizing bandwidth consumption. In [15], the authors investigated the impact of different isolation levels on resource occupation in reliable slicing. They proposed an integer linear program (ILP) to protect the deployed services from single fiber link failure. To protect the service from a single SF instance failure, authors in [21] proposed a heuristic algorithm to steer the traffic for a given SFC reliably. Multiple and One-Type Failures: Considering the coincidence of multiple and one-type failures, Refs. [11], [14], [16], [17] proposed heuristic or approximate approaches. To protect against multiple link failures, the authors in [11] designed backup schemes and proposed a probabilistic distribution function to minimize the required backup resource in polynomial time. In [14], exploiting content connectivity, the authors proposed an ILP model to reliably map the virtual network and make it fault-tolerant for multiple link failures. Taking multiple node failures into account, Ref. [16] proposed a graph theory-based algorithm to compute the minimum required backup transmission resource. Ref. [17] investigated how to place backup nodes to protect the network from multiple physical node failures while minimizing the backup computing resource consumption. Single and Mixed-Type Failure: During service delivery, failures of different types (e.g., link, server, SF instance) might occur one after another (i.e., one failure is fixed before the subsequent failure occurs). To guarantee service delivery, Refs. [18], [22], [23] proposed heuristic and approximate approaches to handle single and mixed-type failure. Ref. [18] proposed a primary and backup resource allocation model using probabilistic protection to protect the deployed services. Ref. [22] proposed a method for embedding an SFC via two linkdisjoint SFPs to protect the service delivery from single mixedtype failure. Taking SF instance distribution into account, Ref. [23] proposed an algorithm to backup the in-service SF instances in an off-site manner. Multiple and Mixed-Type Failures: In practice, failures with different types may co-occur. Compared to the single and mixed-type failure, multiple and mixed-type failures are more complex as the protection approach needs to jointly take failures of all types into account instead of handling them one at a time. To the best of our knowledge, how to protect the service delivery process against multiple and diverse failures is challenging and needs to be studied. In the following sections, to fill this gap, we first introduce the preliminary discussion for the proposed technique in augmented graphs, then we formulate the problem of deterministic-fault-tolerant SFC embedding, and propose efficient heuristics to solve the problem. Fig. 2 shows three typical failures in SFC service delivery. In Fig. 2a, an SFC ( ⇒ ⇒ ⇒ ⇒ is delivered through an SFP ( → SEV → SEV → ). In this SFC, , are the source and destination, while , , are the required SFs. In the SFP, SEV hosts service function instances for and , while SEV hosts 's instance. Fig. 2b shows that a link failure occurs between SEV and SEV . It interrupts all SFPs that bypass this failed link. Here, a backup route SEV → SEV → SEV can help the SFPs recover from the link failure that occurs between SEV and SEV . Fig. 2c shows an SF instance failure at SEV . It only impacts one SFP that employs this failed SF instance. Here, a backup SF instance can be initialized at SEV to protect the service. Fig. 2d shows SEV 's failure, which impacts all SF instances on this server ( and ), leading to service disruption of multiple SFPs that require data processing from this server. Similar to [36], this work assumes that a server failure does not affect the node's routing functionality. Therefore, SEV can perform the role of the backup server that initializes all backup SF instances for SEV , and a backup route SEV → SEV → SEV is employed to ensure SFC delivery.

A. Network Failures in Service Delivery
The above three schemes protect SFC delivery from a single and one-type failure. However, directly applying these approaches might not be efficient when diverse failures coincide. For example, when applying the technique in Fig. 2c for joint failures of 's instance and the link between SEV and SEV , the SFC delivery process will be disrupted. To efficiently protect service delivery against multiple and diverse failures, we broadly specify the SFC delivery into two processes: (1) SF execution and (2) routing. The SF execution process deals with the client's data through the required SFs, while the routing process transmits the client's data from the source to the destination. Making an SFC delivery fault-tolerant is equivalent to making these two processes fault-tolerant. To this end, we propose two inter-related augmented graphs to achieve fault tolerance for the SF execution and routing processes in the following subsections.

B. k-Connected Service Function Slicing (KC-SFS)
We use an integer k to indicate the level of deterministic fault tolerance from a client's request. The k-fault tolerance means the SFC delivery process can survive up to k-1 link failures and k-1 node (including server and SF instance) failures. Here, we propose a k-connected SF slice (KC-SFS) augmented graph based on network slicing and k-edge-connected graph techniques to facilitate deterministic fault tolerance and resource sharing during SFC embedding.
Inspired by the network slicing technique, we introduce the service function slice (SFS) augmented graph. We use a 3-tuple SFS , , to represent an SF slice, where represents a specific SF, is the set of 's instances, and represents the virtual connections among 's instances. Fig. 3a shows an example of an 's slice, where is the instance of . Different from the network slice, an SFS may not be connected. Embedding an SFS is similar to virtual network embedding, whereas one SF instance is hosted by one dedicated physical node, and one virtual link in SFS is accommodated by reserving bandwidth either at a physical link (i.e., ⇔ to ↔ ) or along a physical path (i.e., ⇔ to ↔ ↔ ). SFS allows resource sharing among multiple SFCs. SFS is scalable as one newly-installed SF instance can directly join the corresponding SFS, and one new SF can instantiate a corresponding SFS without impacting the existing SF slices.
In graph theory, a k-edge-connected graph stays connected after removing any k-1 edges 1 [24]. As a link failure in a PN is similar to removing an edge from a graph, we extend the SF slice augmented graph to the k-connected SF slice (KC-SFS) augmented graph. A KC-SFS is represented by a 4-tuple -SFS , , , . When using δ as the degree of a node, a KC-SFS owns the following features: (1) it is connected, (2) each SF instance connects to at least k other SF instances (i.e., δ , ∀ ∈ ), (3) the number of maximum flows between any two SF instances is no less than k, and (4) there are no parallel edges between two SF instances (i.e., ). When embedding a KC-SFS, each SF instance is initialized at one dedicated server, while edges must be embedded onto linkdisjoint paths in the PN. Specifically, for every two edges in (a) An example of service function slice (SFS).
(b) Embedding a 2connected SF slice. Fig. 3: SF slice and k-connected SF slice. 1 In this work, "edge" represents an arc in the graph or service function slice, while "link" refers to a connection in the network. (c) SF instance failure and solution.
(d) Physical server failure and solution. KC-SFS, there is no intersection between two physical paths that host them. Fig. 3b illustrates an example of embedding a 2connected SFS onto a PN, where the circled number represents the virtual link embedding result. Each edge in Fig. 3b is hosted by a physical path (link) that is link-disjoint from the others. As in work [36], this work also assumes that every physical node comprises a server and a routing component (e.g., router, switch, etc.). Thus, a server failure only impacts SF executions on this physical node instead of routing functionality. Proof. Since each SF instance connects to at least k other SF instances in a KC-SFS, the minimum degree of an SF instance is k. Based on Menger's theorem, a KC-SFS is a k-edgeconnected graph [24]. As every edge in KC-SFS is embedded onto a link-disjoint path, every link failure in PN only impacts one edge in KC-SFS. Due to a link-disjoint embedding policy, k-1 physical link failures can at most break k-1 edges in KC-SFS. Therefore, KC-SFS and its embedding result remain connected after k-1 physical link failures in the PN. ∎

Lemma 2. The embedding result of a KC-SFS can protect against k-1 SF instance failures.
Proof. Since the quantity of SF instances in a KC-SFS is at least k, at least one instance survives after k-1 SF instance failures.
As KC-SFS is connected, the embedding result of a KC-SFS can tolerate k-1 SF instance failures. ∎

Lemma 3. The embedding result of a KC-SFS can protect against k-1 physical server failures.
Proof. Since each server only installs one instance, k-1 server failures are equivalent to k-1 SF instance failures at one specific KC-SFS. Based on Lemma 2, this lemma holds. Proof. Based on Lemmas 1 and 3, the embedding result remains connected after k-1 link failures, while at least one server survives after k-1 server failures. In other words, the embedding result is connected, and there is at least one available path from any failed server to the survived server. Thus, no matter which failed server is employed for the reliable service, one available path always connects this failed server to the survived server. As a result, the embedding result can protect against k-1 link failures and k-1 server failures. ∎ Based on Theorem 1, Lemma 2, and Lemma 3, the following lemma holds.

Lemma 4. The embedding result of a KC-SFS can jointly protect against k-1 link failures and k-1 SF instance failures.
According to the above analysis, employing KC-SFS for every required SF makes the SF execution process fault-tolerant. Next, we discuss how to provide fault tolerance on the routing process for a KC-SLG.

C. k-Connected SFS based Layered Graph
As various SFs have diverse instances distributed across the PN, each required SF must generate one KC-SFS to provide deterministic fault tolerance. We use to represent the set of k-connected SF slices. For convenience, we denote an SFC request by SFC , , , … , , , where represents the number of SFs in the SFC. Correspondingly, the set of KC-SFS is represented by , -SFS , … , -SFS , . Next, we propose the k-connected SFS-based layered graph (KC-SLG) to make the routing process deterministically fault-tolerant.
A KC-SLG is represented by a 2-tuple KC-SLG = E , , where E represents the set of routing edges in KC-SLG. Specifically, there are k routing edges connecting each two adjacent k-connected SF slices in KC-SLG. Based on the index of each SF, the set of routing edges in a KC-SLG can be represented by E E , , E , , … , E , , where E , is the set of routing edges between the and 1 KC-SFS. Based on Menger's theorem, a KC-SLG is a k-edgeconnected graph. If every edge in KC-SLG is embedded onto a link-disjoint path, based on Theorem 1, the embedding result is k-fault-tolerant at the expense of high bandwidth consumption. To save the network resource while guaranteeing deterministic fault tolerance, we employ the following embedding policy: (1) edges in the same KC-SFS (e.g., all edges in 2-SFS ) or the same routing edge set (e.g., all edges in E , ) should be embedded onto link-disjoint paths, and (2) edges in different KC-SFS (e.g., an edge in 2-SFS and an edge in 3-SFS ) and routing edge sets (e.g., an edge in E , and an edge in E , ) can share the same physical path (link). Theorem 2 illustrates that the above embedding policy can guarantee deterministic fault tolerance. Meanwhile, there is only one activated SFP when delivering an SFC. Given as the bandwidth resource demand, every link that supports an edge in KC-SLG only needs to reserve bw bandwidth. That is, even though one physical link may host multiple edges in one KC-SLG, only bw bandwidth in each direction is reserved by this physical link.

Theorem 2. The embedding result of a KC-SLG can protect against k-1 link failures and k-1 server failures.
Proof. Based on the proposed KC-SLG embedding policy, a link failure in the PN can impact at most one edge at each routing edge set or KC-SFS in KC-SLG. This is because every edge in the same routing edge set or KC-SFS is embedded onto link-disjoint paths. When k-1 link failures coincide, there is at least one edge survived at each routing edge set, and each KC-SFS remains connected according to Lemma 1. Thus, KC-SLG remains connected. In addition, a server failure impacts at most one SF instance in every KC-SFS. As geographically-

A. Optical Edge Network (OEN)
We employ the optical edge network as the substrate (or physical) network, where edge servers are connected via fiber links [14], [25]- [27]. The optical edge network (OEN) is denoted by OEN , , , where OEN is -edge-connected, while and represent the set of nodes and bidirectional fiber links, respectively. In our assumption, every physical node has a wavelength converter, and we leave the extension to the case of wavelength continuity for future work. A physical node ∈ hosts a set of SF instances denoted by , and it can support at most instances of an SF ∈ . Each fiber link ∈ is bidirectional and has available wavelength resources, each of which supports a certain amount of bandwidth. For convenience, a fiber link is represented by , , where , ∈ are its endpoints. A lightpath is composed of multiple fiber links, and denotes the set of lightpaths in the OEN. As there can be several lightpaths from one node to another, we use , , to represent the lightpath from to . Note that ∈ 0, |ℙ , | , where ℙ , is a lightpath set and includes all lightpaths whose endpoints are , , and ℙ , ⊂ .

B. Ultra-Reliable SFC Request (USR)
An ultra-reliable SFC request is denoted by a 4-tuple USR , , , , where denotes the level of deterministic fault tolerance, is the set of required SFs (including source and destination ), represents the SFs' execution order, and is the number of demanded wavelength resources. To guarantee deterministic fault tolerance, must be no more than of a given OEN (i.e., ). The number of required SFs in an SFC is .

C. Problem Formulation
Given a USR and an OEN, we investigate a problem of how to deliver USR over OEN with a deterministic fault tolerance such that wavelength resource consumption is minimized. We call this problem deterministic-fault-tolerant SFC embedding (DFT-SFCE), which jointly creates and embeds a KC-SLG onto the shared OEN. The DFT-SFCE is specified to the k-connected SF slicing and routing processes to guarantee the deterministic fault tolerance of delivering a reliable SFC. Table I lists the notations used in the problem formulation. For each SF in the request, we consider composing and embedding the slice of onto the physical nodes that have installed the corresponding instance, and this set of physical nodes is denoted by . The objective of the proposed DFT-SFCE is to minimize wavelength resource consumption as below: k-Connected Service Function Slicing: In this process, edges are embedded via link-disjoint lightpaths to connect the instances of . Eqs. (2) and (3)  (2) , 1, , is used to host an edge in KC SFS, 0, otherwise. (3) , , ∈ , ∀ ∈ , ∀ ∈ 1, , ∀ ∈ 0, |ℙ , | , ,

KC-SLG Routing Embedding:
The edges in the same must be embedded onto link-disjoint lightpaths. Eqs. (6) and (7) represent whether , , and , are used to host a routing edge or not. Eq. (8) ensures that there are at least lightpaths between any two adjacent KC-SFS. Note that 0 represents the source node, while 1 represents the destination. Eq. (9) constrains each fiber link to host at most one routing edge between any two KC-SFS. In other words, edges in the same routing edge set are embedded onto link-joint lightpaths.   Level of deterministic fault tolerance.
Number of required wavelength resources.
, Number of available wavelength resources at , .

(7)
, , , , , , KC-SLG Embedding: Eq. (10) identifies whether a fiber link is used for KC-SLG embedding or not. Eq. (11) determines whether a fiber link , is used to host an edge in one KC-SFS or routing edge set. Note that, in Eq. (11), is a very large integer that ensures , is either 0 or 1. Eq. (12) requires that any fiber links used for embedding KC-SLG should have enough wavelength resources. , V. NP-HARDNESS ANALYSIS In this section, we analyze the NP-hardness of the proposed DFT-SFCE problem in various networking scenarios. We first illustrate that, when given an OEN and a USR, there exists a solution for DFT-SFCE if wavelength resources are enough at each fiber link and .

Theorem 3. When given an OEN with enough wavelength resources, there exists a solution for DFT-SFCE if .
Proof. Since each fiber link in OEN has enough wavelength resources, the given OEN is -edge-connected. As and one SF slice with a higher fault tolerance level can participate in the KC-SLG with a lower fault tolerance level, the given OEN can be regarded as a KC-SLG composed of replicas of itself which is one solution for DFT-SFCE. ∎ According to Theorem 3, the following lemma holds.

Lemma 6. After pruning the fiber links without enough wavelength resources, there must exist a solution for DFT-SFCE if the number of maximum flows between any two nodes is no less than k in the pruned OEN.
Next, we prove that minimizing wavelength resource consumption for composing and embedding a KC-SLG over a given OEN is NP-hard. Specifically, we discuss the NPhardness of the k-connected SF slicing and routing processes. Proof. We start our proof with a particular scenario where all physical nodes have instantiated one required SF instance. In this scenario, using the minimum number of wavelength resources to compose and embed this KC-SFS is equivalent to finding the k-edge-connected spanning subgraph with the minimum size (i.e., the number of edges in the subgraph). Since finding the minimum k-edge-connected spanning subgraph is NP-hard, minimizing wavelength resource consumption of composing and embedding a KC-SFS when all physical nodes have one required SF instance is also NP-hard [28]. When some physical nodes instantiate the required SF instance, this problem remains NP-hard. When k = 1, regarding the physical node that instantiates one required SF instance as a sink, this problem becomes the minimum Steiner tree problem [29]. Overall, minimizing wavelength resource consumption for composing and embedding one KC-SFS is NP-hard. ∎ Since diverse KC-SFS can share wavelength resources to host their edges, composing and embedding all KC-SFS in a KC-SLG is equivalent to a collaborative process of maximizing the sharing of wavelength resources among all required KC-SFS. Thus, the following lemma holds according to Theorem 4.

Lemma 7. Minimizing the wavelength resource cost for composing and embedding all KC-SFS in a KC-SLG is NP-hard.
Next, we discuss the NP-hardness of the routing process in DFT-SFCE. The edges in the same routing edge set are required to be embedded onto link-disjoint lightpaths. Minimizing wavelength resource consumption of this process is equivalent to the k edge-disjoint shortest paths (KDSP) problem, which is NP-hard [30]. Accordingly, the following lemma holds.

Lemma 8. Minimizing wavelength resource consumption for the routing process in DFT-SFCE is NP-hard.
Overall, optimizing DFT-SFCE is challenging as the optimization problem of either process (i.e., k-connected SF slicing process or routing process) is NP-hard. To study this problem, we first investigate the k-connected SFS embedding process in the following scenarios: (1) all physical are candidates of the required SF, and (2) some physical nodes are candidates of the required SF. Correspondingly, we propose the k-connected network slicing (KC-NS) scheme for scenario (1) and subsequently extend it for scenario (2), namely, kconnected function slicing (KC-FS). With the above techniques, we then propose the most candidate first SF layered graph embedding (MCF-SE) algorithm to jointly optimize KC-SLG's composing and embedding processes in DFT-SFCE.

A. k-Connected Network Slicing
First, we investigate the k-connected SFS embedding process when the required SF has been installed at every edge server in a shared OEN. Ideally, when the OEN is a complete graph (i.e., each edge server is directly connected to each other through a dedicated fiber link), a lower bound on wavelength resource consumption of embedding a k-connected SFS is | | * * , where each SF instance connects to at least k other neighbors, and the round-up process works when both | | and are odd.
Since the OEN is probably not a complete graph in practice, it is hard to achieve the lower bound, as proved by Theorem 4. Based on this lower bound, wavelength resource consumption of embedding a k-connected SFS is correlated to the node degree in the embedding result. We use Fig. 5 to demonstrate this relationship. Fig. 5a shows an embedding result for a 2connected SFS with wavelength resource consumption of 4 * , where the average degree in the embedding result is 2. In contrast, another embedding result is shown in Fig. 5b, where 5 * wavelength resources are needed and the average node degree is 2.5. If we use to denote the average degree in the embedding result, wavelength resource consumption can be represented by | | * * . Thus, reducing wavelength resource consumption is equivalent to lowering the average degree in the embedding result.
Following this logic, we propose k-connected network slicing (KC-NS) in Algorithm 1. KC-NS takes OEN, , and as inputs, and outputs an embedding result , , where represents the set of fiber links used in . Line 1 prunes the fiber links without enough wavelength resources, and the pruned graph is denoted by . Lines 2-4 verify whether meets the level of deterministic fault tolerance or not. When meets the level of deterministic fault tolerance, KC-NS first uses the depth-first search (DFS) algorithm to generate a DFS tree Γ to make the embedding result connected (Line 5). Meanwhile, to achieve a low average degree in , an index number i ( ) is introduced, and Line 6 calls the i-based node degree balancing (i-NDB) process to reserve fiber links for until it is k-edge-connected. At last, KC-NS returns the embedding result.
Next, we elaborate on how fiber links are reserved by the ibased node degree balancing process in Algorithm 2. Lines 3-10 maintain a node-set Δ including the nodes in whose degree is less than . When Δ is not empty, to make every node in Δ have degrees, fiber links are repeatedly reserved according to two policies: (1) if there exists a neighbor set ℕ ( , ∀ ∈ ℕ ) for a node ( ∈ Δ ), a fiber link is then reserved between and the physical node with the least degree in ℕ (Lines 6-7), or (2) if ℕ does not exist, a fiber link between and the node with the highest available degree (i.e., ) is reserved, where and represent the node degree of in and (Line 8). In graph theory, a graph is k-edge-connected if and only if the number of maximum flows between any pair of nodes is no less than k [24]. Here, if the number of maximum flows between two nodes in S is less than i, the set of lightpaths between these two nodes in S is called the i-bridge, and these two nodes are called endpoints of this i-bridge. In Line 12, the algorithm first identifies endpoints of all i-bridges by applying the maximum flow algorithm on every pair of nodes [31], and saves them into a node-set Δ . According to Theorem 3, OEN is -edge-connected ( ), and an unreserved lightpath can always be found to make the embedding result i-edge-connected at each iteration. Therefore, Lines 12-15 repeatedly eliminate i-bridges by reserving new lightpaths between their endpoints. At last, the algorithm returns as the output.

Theorem 5. KC-NS embeds a k-connected SFS onto a shared OEN with at most twice wavelength resource consumption of the optimal solution.
Proof. This theorem uses OPT to represent the optimal wavelength resource consumption of embedding a k-connected SFS onto a shared OEN, and the lower bound of embedding a k-connected SF slice is shown in Eq. (13).
Since the DFS algorithm spans the given OEN, the length of the generated DFS tree (i.e., number of fiber links) is |N 1|. As (a) Embedding result with 2.
(b) Embedding result with 2.5. Fig. 5: Impact of average degree in embedding results. OEN is -edge-connected, each node has at least neighbors [24]. When using Θ to represent the number of fiber links reserved for making the embedding result k-edge-connected at each iteration, Eq. (14) holds. In the worst case, all physical nodes are connected via policy (2) at each iteration (at most |N-1| fiber links are reserved), and no i-bridge will be generated.
When using to present the approximation ratio, Eq. (16) shows the relationship between the optimal solution and our proposed KC-NS algorithm.
Therefore, we proved that the proposed algorithm achieves a 2approximation when embedding a k-connected SFS onto an OEN, where all nodes have installed a required SF instance. ∎

B. k-Connected Function Slicing
The embedding result of KC-NS includes all nodes across the OEN. When some physical nodes are candidates of a required SF slice, the embedding result generated by KC-NS can also accommodate this SF slice with the same level of deterministic fault tolerance. When accommodating such an SF slice, the physical nodes without the required SF instances and associated fiber connections should be removed from the KC-NS's result to save wavelength resources. But, simply removing those physical nodes and fiber connections may break the k-edgeconnected feature. To reduce wavelength resource consumption and maintain the k-edge-connected feature, we propose kconnected function slicing (KC-FS) as Algorithm 3.
KC-FS takes the pruned OEN , , , and one required SF as inputs, and outputs an SF slice embedding result . An initial solution is obtained by applying the KC-NS algorithm as Line 1. In Line 2, the physical nodes that provide the required SF instance are included in a node-set . In Lines 3-7, KC-FS repeatedly deletes lightpaths bypassing physical nodes without the required SF instances. In Lines 8-12, KC-FS repeatedly substitutes a long lightpath with a shorter lightpath, which is link-disjoint with , . At last, in Line 13, KC-FS returns the embedding result of 's slice.
Specifically, we elaborate on how the KC-FS algorithm can reduce wavelength resource consumption while satisfying the required level of deterministic fault tolerance. We use , to represent the set of fiber links in a lightpath , . For each lightpath , only bypassing physical nodes without the required SF instances, KC-FS determines whether removing , makes physical node and violate the level of deterministic fault tolerance or not (Lines 3-4). If not, , is removable and will be eliminated from (Lines 5-7). After eliminating the removable light paths, long lightpath connections may exist in . For each lightpath , in , Lines 8-12 check whether there exists a shorter lightpath , compared to , or not. If yes, , substitutes , to save wavelength resources. Note that , must be link-disjoint to , such that fault tolerance can be satisfied.

C. k-Connected SF Slices Layered Graph Composition and Embedding
Intuitively, we can compose and embed the k-connected SF slices layered graph by (1) independently running KC-FS on every required SF, and (2) finding k link-disjoint paths to connect their embedding results for each two adjacent SFs in SFC. But, we find that additional wavelength resources might be introduced when independently optimizing each SF slice embedding process. This is because there is only one activated SFP, and different SFS embedding results can share usages of fiber connections to reduce wavelength consumption as they may have common physical candidates. We use Fig. 6 to show this finding via two independently embedded SF slices with 2. In Fig. 6, curly brackets beside each physical node indicate the SF instances, while the blue-dashed and red-dotted links are the fiber links reserved for slices of and . To independently minimize wavelength resource consumption, fiber links , , , , , , and , are employed to connect SF instances of in Fig. 6a, while , , , and , are employed (a) ′ embedding result. (b) 's embedding result. Fig. 6: Impact of independently embedding SF slices.

Algorithm 3 k-Connected SF Slicing (KC-FS).
Input: , , k, ； Output: , ； 1: -( , , ); 2: Create node-set ∈ , ∀ ∈ ; 3: For each lightpath , ( , ∈ ) that only bypasses physical nodes in } do 4: If Removing , does not make the number of maximum flows between and less than k 5: , ; 6: End If 7: End For 8: For each pair of physical nodes , ∈ do 9: If there is a lightpath , that has a shorter length, than , in and , ∩ , ∅ 10: for connecting instances for . In this way, 5 * wavelength resources are reserved. The candidates for are the subset of the candidates for (i.e., and have physical candidates in common). When directly employing the embedding result of 's slice to accommodate , there is no need to reserve , . In this way, only 4 * wavelength resources are needed. Generally, an SFC includes more than one SFs, so multiple SF slices need to be accommodated onto the OEN. We specify the required SF slices into two types: the embedded SF slices and the unembedded ones. We now discuss what if there exist uncommon candidates between the unembedded and embedded SF slices. In graph theory, when a new vertex joins a k-edgeconnected graph, to maintain the k-edge-connectivity, k edgedisjoint paths are needed to connect this new vertex to the graph [24]. Similarly, when incorporating an uncommon physical candidate into the embedding result, k link-disjoint lightpaths are required. For an unembedded SF slice, this reduces wavelength resource consumption by connecting the uncommon candidate to the common ones through reserved fiber connections. We use Fig. 7 to show this benefit, where the blue-dashed links are already reserved by slices of and in Fig. 6 and the red-dotted links are newly reserved by 's slice. In Fig. 7a, nodes E and F host an instance for . When independently composing and embedding 's slice while ensuring the 2-fault tolerance, , , , and are reserved, where 3 * wavelength resources are required. However, when taking the embedded SF slice into account, only , and , need to be reserved. This is because (1) physical node E lies on the lightpath of ↔ ↔ that other SF slices have reserved, and (2) physical node F needs to connect with the embedded SF slices (i.e., A, B, C, and D) via two link-disjoint lightpaths (i.e., , and , ). The embedding result with 2 * wavelength resources is shown in Fig. 7b.
As one can see, sharing usages of fiber connections among the required SF slices can save wavelength resources, and the size of the first embedded SF slice matters. This is because the larger the size of the first embedded SF slice is, the higher probability that the connections among the candidates of the embedded slice can be effectively shared with the unembedded ones. To incorporate the above findings, we propose the most candidate first SF slices layered graph embedding (MCF-SE) algorithm as Algorithm 4. The MCF-SE algorithm takes the pruned OEN and USR as inputs, and outputs a k-connected SF slices layered graph (KC-SFG). The algorithm selects the SF ′ with the most instances in the pruned OEN (Line 1). Then, it employs the KC-FS algorithm to compose and embed the SF slice for ′ over the OEN, where and represent the physical candidates and the fiber links used for hosting this slice (Lines 2). Next, the algorithm creates an empty lightpath set to avoid a fiber link being reserved more than once by the same SF slice. For one SF other than ′, the algorithm checks whether uncommon candidates exist between and ′ (Line 3-5). If they do exist, for each uncommon candidate between and ′, the algorithm finds link-disjoint lightpaths to connect it to (Line 6). These link-disjoint lightpaths are included in a set , and must be link-disjoint from the lightpaths in . Then, this physical candidate is added to , and , is updated in (Line 7). When all physical candidates of are included in , the newly-reserved fiber links are added to (Line 9). The algorithm repeats Lines 4-9 until all SF slices are accommodated. Lines 11-15 eliminate lightpaths associated with the over-protected physical candidates while not violating the deterministic fault tolerance. At last, this algorithm returns the KC-SLG composed of and . We employ Fig. 8 to demonstrate how the proposed MCF-SE algorithm works. Fig. 8a shows an example of an OEN, where the curly bracket beside the physical node shows the instances installed on this node. There is an SFC request with k = 2, which starts at node C, terminates at node F, and demands and . In Fig. 8, dark links represent connections in OEN, while red-dotted and blue-dashed links are newly added to and exist in , respectively. Taking the OEN in Fig. 8a and USR as inputs, MCF-SE generates a 2-edge-connected spanning subgraph (red-dotted links) of the OEN as Fig. 8b. Next, the MCF-SE algorithm applies KC-FS to generate the embedding result for 's slice by (1) eliminating unnecessary lightpath ↔ ↔ ↔ , and (2) substituting the long lightpath ↔ ↔ with the shorter lightpath ↔ as shown in Fig. 8c. To accommodate slice onto the OEN while taking embedding result of slice into account, lightpath ↔ ↔ is reserved. Next, as deleting lightpath E ↔ F does not make physical nodes E and F violate the level of deterministic fault tolerance, lightpath ↔ is removed. At last, the embedding result of the KC-SFG is shown in Fig. 8d.
Note that the KC-SFG created by the MCF-SE algorithm is a k-edge-connected graph. Supported by Theorem 3, a k-edgeconnected subgraph must exist for any SF slice, and k linkdisjoint lightpaths must exist for any routing edge set. Based on Theorem 2 and Lemma 5, an available SFP can always be found by running SFP construction algorithms such as [32][33] after at most k-1 fiber link(s) and k-1 node(s) failures occur.

VII. EXPERIMENTAL RESULTS AND ANALYSIS
In this section, we implement the proposed schemes on diverse networking scenarios to evaluate their performances.

A. Simulation Settings
Based on [14], [25]- [27], OEN can be composed of a main ring and multiple sub-rings with dense connectivity, and we employ three network structures to perform our evaluations, (1) 2-D n-Torus network, (2) 4-degree n-ring network, and (3)edge-connected random network ( 4). According to [34], the size of a 2-D n-Torus network is . Fig. 9a shows an example of a 2-D 4-Torus network. With wrap-around links (red-dashed links in Fig. 9a), there is a ring in every line and column, while every node has a degree of 4. The size of a 4degree n-ring is 4 * . Fig. 9b shows an example of such a network, where every ring in the dark represents a main ring (e.g., a ring of 13,14,15,16), while every ring with red-dashed curves is a sub-ring (e.g., a ring of 1, 5, 13, 12). The network in Fig. 9b comprises 4 sub-rings. It is worth noting that both network structures in Fig. 9 are scalable based on the number .
If not otherwise specified, in an OEN, each link provides [100, 200] wavelengths, each edge server hosts [1,4] types of SF instances, and each SF has [4,16] physical candidates. Specifically, in a random network, the minimum degree is set in the range of [4,7]. We generate 1000 copies of the 2-D 4-Torus network, 4-degree 4-ring network, and 12-,16-,20-,24nodes random networks within the above settings. For a reliable SFC request (USR), the length of the SFC is set in [2,10], the level of deterministic fault tolerance (k) is set in [2,4], while the number of demanded wavelength resources is set in [1,4]. Meanwhile, the number of USR is set to 100. To evaluate the survivability of the embedded requests, we randomly generate [2,12] mixed-types failures (including server failure, link failure, and SF instance failure) in the OEN.

B. Evaluation Metrics
We evaluate the performance of the proposed schemes in terms of the following metrics: Wavelength Resource Consumption: We use to represent wavelength resource consumption of scheme .

Survivability:
We use to represent the ratio between the number of ongoing services deployed by the scheme after failures and the total number of services. Approximation Ratio: We use approximation ratio (AR) to evaluate the gap between the performance of the proposed KC-NS and the optimal solution.

Cost-Protection
Moreover, we extend and implement the exhaustive search algorithm, primary and backup service function chaining and embedding (PB-SFCE) [22], and protection centrality-based pairwise node protections (PC-PNP) [23] for comparisons. To verify the approximate performance of KC-NS, we implement the exhaustive search algorithm to obtain the optimal solution. For PB-SFCE, we extend it by (1) generating one primary SFP and saving it in a set , (2) finding an SFP link-disjoint to any SFP in , and adding it to , and (3) repeating step (2) until the size of is k. We name this method "k-PB-SFCE". For PC-PNP, we extend it by (1) deploying the required SFC via stateof-the-art [32] [33], and (2) for each primary SF instance, finding the k-1 nearest backup instances and connecting the primary instance to the backup instances via the shortest path. (b) 4-degree 4-ring network. Fig. 9: Example of network structures.

C. Approximation Analysis for KC-NS
When every physical node provides one instance for the required SF, we compare the performance of the proposed KC-NS algorithm to the exhaustive search approach to verify its 2approximation. In Figs. 10 and 11, blue and red bars represent wavelength resource consumption of KC-NS and exhaustive search as indicated by the left y-axis. The yellow-solid curve is the approximation ratio between these two approaches, labeled by the right y-axis.
In Fig. 10, both KC-NS and exhaustive search need more wavelength resources when increasing the network size. The larger the network is, the more wavelength resources are reserved to achieve the k-fault tolerance. As one can see from Figs. 10a, 10b, and 10c, the performance of KC-NS is near the optimal result when the network size is small, and the approximation ratio increases with the network size. The DFS process likely generates a tree with fewer leaves in a small network than in a large network. When converting the DFS tree to a 2-edge-connected spanning subgraph (i.e., Lines 2-11 in Algorithm 2), a tree with fewer leaves likely generates a 2-edgeconnected spanning subgraph with a relatively low average degree. Since wavelength resource consumption of KC-NS is strongly dependent on the average degree in the embedding result, the performance of KC-NS is near-optimal when the network size is small. The DFS likely generates a tree with more leaves in a large network, so the approximation ratio increases with the network size. Moreover, when increasing the k value, the KC-NS algorithm can achieve a lower approximation ratio even though more wavelength resources are needed. A higher k value means more iterations are needed by the i-based degree balancing process, thus reducing the average node degree in the embedding result. Again, as wavelength resource consumption is positively related to the average degree, a higher k value makes the performance of KC-NS closer to the optimal result and leads to a lower approximation ratio. Numerically, when varying the network size, the average approximation ratio that the KC-NS algorithm can achieve with k = 2, 3, and 4 is 1.16, 1.12, and 1.09, respectively.
In Fig. 11, when increasing the network connectivity, KC-NS needs fewer wavelength resources to achieve k-fault tolerance while the performance of exhaustive search remains the same. For a specified network, the number of links in a kedge-connected spanning subgraph is fixed. Increasing the connectivity does not change the number of links in the optimal k-edge-connected spanning subgraph. Thus, the performance of exhaustive search remains the same. For KC-NS, when increasing the connectivity, more physical candidates are processed via policy (1) (i.e., Line 6-7 in Algorithm 2), and the average degree in the embedding result reduces. Therefore, increasing the connectivity of the network benefits the performance of the KC-NS algorithm. Similarly, the approximation ratio decreases when k rises. Numerically, when varying network connectivity, the average approximation ratio of KC-NS with k = 2 and 3 is 1.25 and 1.23, respectively.
According to the above experimental results and analysis, we find that (1) the proposed KC-NS algorithm achieves nearoptimal performance when the network size is small, (2) increasing k value benefits the approximation ratio of the KC-NS algorithm, (3) increasing network connectivity benefits the performance of the proposed KC-NS algorithm, and (4) the average approximation ratio that the KC-NS algorithm can achieve in our experiments is 1.17.

D. Impact of k Analysis for KC-FS
When some physical nodes installed the instance of the required SF, we evaluate the performance of the proposed KC-FS algorithm regarding different deterministic fault tolerance levels. Fig. 12 estimates the impact of the number of physical candidates on wavelength resource consumption and costprotection ratio. Fig. 13 evaluates the impact of the number of coincided failures on the survivability and cost-survivability ratio. For both Figs. 12 and 13, the red bar (solid curve), blue bar (dotted curve), and green bar (dashed curve) represent the performance of KC-FS when k = 2, k = 3, and k = 4, respectively. Bars are measured by the left y-axis, and curves are measured by the right y-axis. Specifically, k-cost (k = 2, 3, 4) represents wavelength resource consumption of KC-FS in both figures, (b) k = 3. Fig. 11: Network connectivity vs. wavelength consumption. and k-ratio is the cost-protection ratio and cost-survivability ratio in Figs. 12 and 13, respectively.
In Fig. 12, when increasing the number of physical candidates of the required SF, wavelength resource consumption and the cost-protection ratio increase for KC-FS with all k values. This is because more physical candidates need more wavelength resources for KC-FS to perform k-fault tolerance. Among all cases, KC-FS with k = 4 requires the highest wavelength resources because a higher deterministic fault tolerance level comes with higher expenses. Interestingly, KC-FS with k = 2 needs the least wavelength resource consumption to perform 2-fault tolerance but has the highest cost-protection ratio. Meanwhile, KC-FS with k = 3 achieves the lowest cost-protection ratio. From these results, we find that, the wavelength resource reserved by an embedding result can be specified into two types: (1) making the embedding result connected (i.e., DFS tree), or (2) achieving k-fault tolerance. Regardless of the k value, a particular SF slice needs the same amount of wavelength resources to construct the DFS tree on a given OEN. In other words, given an OEN, wavelength resource consumption in type (1) is fixed for a particular SF slice regardless of the k value. Regarding this, we further transform Eq. (18) as: CPR (20) where and represent wavelength resource consumption in type (1) and type (2), respectively. As is fixed, when increasing the k value, KC-FS's cost-protection ratio depends on the variation of wavelength resource consumption in type (2) and the k value itself. With the impact of a small k value, KC-FS with k = 2 has the highest costprotection ratio. Since KC-FS with a relatively low k value first employs short lightpaths and long lightpaths are then employed by KC-FS with a relatively high k value, the variation of wavelength resource consumption in type (2) is positively correlated to the k value. That is, a larger k value leads to a faster increase in . Thus, with a moderate k value, KC-FS with k = 3 achieves the lowest cost-protection ratio.
In Fig. 13, we evaluate the performance of KC-FS with diverse k values in terms of survivability and cost-survivability ratio. Here, we set each fiber link with enough wavelength resources such that all USRs are successfully embedded. When increasing the number of random failures, the survivability of all cases decreases, while the cost-survivability ratio of all cases increases. For survivability, KC-FS with k = 4 outperforms the other two cases. For the cost-survivability ratio, KC-FS with k = 2 outperforms the other two cases when the number of random failures is low (i.e., from 2 to 6). When the number of random failures exceeds 8, most USRs deployed by KC-FS with k = 2 fail, leading to a high cost-survivability ratio for KC-FS with k = 2. Even though the USR deployed by KC-FS with k = 4 has the highest survivability, its cost-survivability ratio is high due to high wavelength resource consumption. Numerically, the average cost-survivability ratio of KC-FS with k = 2, k = 3, and k = 4 are 29.31, 27.08 and 34.41, respectively.
According to the above results, we find that (1) wavelength resource consumption of employing KC-FS to embed an SF slice is positively correlated to the number of its physical candidates, (2) KC-FS with k = 3 has the best cost-protection ratio when k is in the range of [2,4], and (3) on average, KC-FS with k = 3 has the best cost-survivability ratio.

E. Efficiency Evaluation and Analysis for MCF-SE
Based on the above discussions, the KC-FS scheme achieves the best cost-protection ratio and the best cost-survivability ratio on average when k = 3. Accordingly, we set k = 3 for MCF-SE, k-PB-SFCE, and PC-PNP. Specifically, 3-PB-SFCE creates one primary SFP and two link-disjoint backup SFPs, while each primary SF instance in PC-PNP connects to two nearest backup SF instances via link-disjoint lightpaths. In Figs. 14, 15, and 16, the red bar (circle curve), blue bar (square curve), and green bar (triangle curve) represent the performance of PC-PNP, 3-PB-SFCE, and MCF-SE, respectively. Bars and curves are evaluated by the left y-axis and the right y-axis, respectively.
In Fig. 14, when increasing the number of physical candidates, wavelength resource consumption of PC-PNP and 3-PB-SFCE decreases. More physical candidates facilitate reducing the length of the SFP, thus consuming fewer wavelength resources for both PC-PNP and 3-PB-SFCE. In contrast, the performance of KC-FS is positively correlated to the number of physical candidates, and MCF-SE needs more   wavelength resources when increasing the number of physical candidates. Due to this, when the number of physical candidates is small (i.e., 4 or 6), MCF-SE needs fewer wavelength resources than the other two schemes. When the number of physical candidates is large (i.e., 10), it needs more wavelength resources. Interestingly, when the number of physical candidates increases from 4 to 6, wavelength resource consumption of MCF-SE increases sharply. Meanwhile, when the number of physical candidates increases from 6 to 10, wavelength resource consumption of MCF-SE increases slowly. More physical candidates increase the probability that different SFs can share the connections among the common physical candidates. Therefore, the more physical candidates exist in the OEN, the more pronounced impact of wavelength resources sharing is. Due to this, when the number of physical candidates for each SF is large, the wavelength resources sharing among the required SF is pronounced, leading to a slow increase in wavelength resource consumption. On the contrary, when the number of physical candidates of each SF is small, the impact of physical candidate sharing is minor. Additional wavelength resources are needed to achieve the deterministic fault tolerance (i.e., Lines 3-10 in Algorithm 4), leading to a sharp increase in wavelength resource consumption. As the acceptance ratio is strongly associated with resource usage, the acceptance ratio of 3-PB-SFCE and PC-PNP increases with the number of physical candidates. At the same time, the acceptance ratio decreases with the number of physical candidates for MCF-SE. Numerically, the average acceptance of PC-PNP, 3-PB-SFCE, and MCF-SE are 75.25%, 90.64%, and 85.74%, while the average wavelength resource consumption for PC-PNP, 3-PB-SFCE, and MCF-SE is 28.75, 24.56, and 25.65, respectively.
In Fig. 15, 3-PB-SFCE and PC-PNP require more wavelength resources to deliver the USR reliably when increasing the SFC length. As a longer SFC probably leads to a longer SFP, 3-PB-SFCE and PC-PNP need more wavelength resources. The performance of MCF-SE is not affected by increasing the length of the SFC and outperforms the other two schemes. In MCF-SE, the SFP is generated from the embedding result of the k-connected SF slices layered graph. Since the wavelength resources are reserved for constructing KC-SLG rather than establishing SFP, the length of SFC does not directly impact the performance of MCE-SE. Also, to reduce wavelength resource consumption, MCF-SE tries to maximize the wavelength resources shared among the required SF slices by (1) embedding the SF slice with the most physical candidates first (Line 1) and (2) removing unnecessary connection(s) (Lines 11-15). As a result, it outperforms the other two schemes regarding wavelength resource consumption when varying the SFC length. Again, as the acceptance ratio is strongly associated with resource usage, MCF-SE outperforms the other two schemes. Numerically, when increasing the SFC length, the average acceptance ratios for PC-PNP, 3-PB-SFCE, and MCF-SE are 75.75%, 85.25%, and 92.5%, while wavelength resource consumption of PC-PNP, 3-PB-SFCE, and MCF-SE is 29.56, 25.12, and 22.31, respectively.
In Fig. 16, when multiple and diverse failures coincide, we evaluate the performance of all three schemes according to their survivability and cost-survivability ratio. Here, we set each fiber link with enough wavelength resources to host all USRs. Even though MCF-SE requires relatively higher wavelength resources when the number of physical candidates is large compared to PC-PNP and 3-PB-SFCE, it provides the best fault tolerance. Note that the cost-survivability ratio of 3-PB-SFCE is lower than MCF-SE when the number of random failures is two due to a lower average wavelength consumption. When further increasing the number of random failures, with the best survivability and moderate wavelength resource consumption, MCF-SE has the best cost-survivability ratio compared to the other two schemes. Numerically, the average survivability of PC-PNP, 3-PB-SFCE, and MCF-SE are 63.45%, 73.65%, and 86.8%, respectively, while the cost-survivability ratios of PC-PNP, 3-PB-SFCE, and MCF-SE are 47.58, 34.89, and 28.47.
According to the above results, we find that (1) using wavelength resource sharing, MCF-SE can achieve a relatively high average acceptance ratio, and (2) MCF-SE outperforms the approaches directly extended from the existing work regarding survivability and average cost-survivability ratio.

VIII. CONCLUSION
In this work, we studied the problem of delivering a reliable SFC request over a shared optical edge network while tolerating multiple and diverse failures. We defined the deterministic fault tolerance (k) to indicate the number of failures that a deployed service can jointly tolerate, and a k-fault-tolerant SFP can jointly tolerate any k-1 node failures and k-1 link failures during the delivery process. We formulated a novel problem called deterministic-fault-tolerant SFC embedding (DFT-SFCE). To solve this problem, we proposed an efficient heuristic algorithm called most candidate first SF slices layered graph embedding (MCF-SE), which comprises two inter-related techniques: kconnected network slicing (KC-NS) and k-connected function slicing (KC-FS). Through thorough mathematical analysis, we proved that KC-NS is 2-approximate. Our extensive simulation  results verified the efficiency of the proposed schemes and demonstrated that KC-FS yields the best cost-protection ratio and average cost-survivability ratio with k = 3. In addition, we showed that the proposed MCF-SE achieves better survivability and average cost-survivability ratio compared to the approaches that are directly extended from existing work.