A Database System for State Management in Stateful Network Service Function Chains [Vision]

In the realm of stateful Service Function Chain (SFC) development, we delineate three pivotal challenges: usability, efficiency, and robustness, each crucial to our work’s foundation.

A significant aspect of usability concerns managing diverse state access scopes and execution logics across VNFs. Per-flow states, specific to individual traffic flows, are managed separately by respective instances, while cross-flow states involve shared data accessed and updated concurrently by multiple instances. Managing these concurrent state accesses, ensuring consistency and correct sequencing, is crucial for system integrity. The platform must adeptly handle the varying demands of per-flow and cross-flow states, catering to the wide array of network functions dependent on these state types.

Additionally, harnessing the capabilities of parallel architectures through strategic optimization techniques is fundamental to boost the overall performance and scalability of SFCs. Techniques such as state caching and workload balancing have been proposed to optimize VNF performance by reducing redundant state accesses and balancing loads [8, 7, 13]. Nonetheless, advancing the execution of stateful SFCs requires addressing challenges that include adaptively responding to variable traffic workloads and maximizing multicore architecture utilization, all while considering the integrated structure of the SFC.

Network traffic variability further complicates robustness in SFCs. Variations in traffic can necessitate scaling, load balancing, or straggler mitigation measures, involving complex redistributions of traffic and states across instances [8, 7, 15]. For instance, an increase in network traffic might require scaling up a stateful firewall (Figure 2c), leading to redistribution of security policies and reallocation of network traffic for load balancing. Ensuring COE in such scenarios mandates careful management of state transfers and traffic allocations, ensuring no disruption to the normal functioning of other VNFs within the SFC while suppressing redundant operations.

The evolution of SFC deployment has been marked by the introduction of various VNF frameworks [6, 11, 3, 12, 8, 7]. Despite these developments, concurrently addressing usability, efficiency, and robustness in state management continues to pose significant challenges.

Lack of Uniform API. Current NFV frameworks, such as LibVNF [12], OpenNF [6], and S6 [7], offer APIs for constructing stateful VNFs. LibVNF provides essential interfaces for packet handling and data transmission, enabling fine-grained state exchange control across instances through event buffers and callbacks. OpenNF and S6 elevate state access abstraction from VNF execution, offering APIs that allow instances to retrieve and update network states with strong consistency. However, these frameworks fall short in supporting atomic updates, where multiple state changes must be executed or rolled back collectively. Moreover, their APIs are confined to individual NFs and do not encompass the coordination needed among multiple VNFs within an SFC. MicroNF [3] enables the consolidation and placement of modularized components across VNFs in an SFC, yet it does not support efficient management of per-flow and cross-flow states. These limitations impose substantial coding complexities on developers, particularly in maintaining state consistency and ensuring execution correctness across stateful SFCs.

Inefficient Execution Runtime. While current NFV frameworks implement various concurrency control mechanisms to manage stateful operations, they often incur significant synchronization overhead, especially during high volumes of concurrent updates. Moreover, these frameworks generally do not fully leverage the benefits of parallel processing architectures in dynamic network environments. For instance, FlexState [13] assumes that shared states can be partitioned without synchronization, an approach that is not always feasible for VNFs with inherent state-sharing requirements. OpenNF [6] introduces a two-phase state-sharing protocol, opting for state transfer across instances for eventual consistency or broadcasting updates for strong consistency as needed. S6 [7] employs a distributed shared object model, periodically consolidating local updates into a global state. Similarly, CHC [8] analyzes traffic workloads to determine the most suitable state-sharing technique, be it partitioning, caching, or operation offloading. Despite these advancements in tailoring state-sharing strategies to network conditions, the existing solutions often rely on coarse-grained concurrency controls. This reliance results in significant locking overhead, particularly during frequent updates to shared states, thus adversely affecting the performance and scalability of stateful SFCs.

Insufficient Support for Reliability. Maintaining consistent shared states during concurrent accesses, coupled with ensuring accurate execution amidst network dynamics, presents a complex challenge. Most existing frameworks are tailored to support single NFs with specific network consistency requirements, but they fall short of addressing the broader spectrum of reliability needs in stateful SFCs. For instance, FTMB [16] and Pico Replication [14] provide failure recovery mechanisms for VNFs managing per-flow states. However, they do not adequately address the needs of VNFs dealing with shared cross-flow states. Frameworks such as OpenNF [6], S6 [7], and FlexState [13] facilitate concurrent updates to shared states, but they lack mechanisms to ensure isolated execution and failure recovery for multiple VNFs within an SFC. Although CHC guarantees execution robustness, its performance suffers from a lock-based state-sharing mechanism under highly intensive concurrent state accesses. As a result, developers utilizing these frameworks for stateful SFCs often face additional burdens to ensure COE and reliability, highlighting the need for more comprehensive solutions in this domain.

The stateful SFC domain grapples with significant state management challenges, primarily due to the varied and complex requirements of network functions. A critical issue stems from the tight coupling between state management APIs and their underlying data stores, which hampers adaptability and compounds development difficulties. Moreover, the absence of a standardized approach leads to inefficiencies, as developers are required to navigate multiple state management systems for different NFV scenarios. In light of these challenges, the demand for a unified, high-performance state management system for stateful SFCs is evident. Such a system, equipped with a singular API for various state access operations, would not only streamline development processes but also enhance overall system performance through efficient resource utilization and dynamic scheduling. A unified solution would ease the integration of VNFs across diverse operational contexts and simplify adherence to diverse reliability and consistency standards.

To facilitate the SFC development, DB4NFV incorporates transactional semantics into stateful SFC declarations, providing users with a well-structured approach to defining complex VNF behaviors. The APIs are summarized in Table I.

Transactional semantics integration into VNF shared state management enhances the development of stateful SFCs and improves shared state management with well-defined transactional dependencies. However, mere transactional representation of state access operations is insufficient to mitigate synchronization conflicts under concurrent accesses. DB4NFV, therefore, employs multiple optimization techniques to leverage parallel architecture effectively and boost SFC performance.

Adaptive Transaction Workload Scheduling. DB4NFV identifies the fine-grained workload dependencies among state access operations before execution. These processes are performed based on stage, indicating the position of VNFs in the SFC (Section III-B4). Stage restricts the boundary for parallel execution. Transaction requests from the same stage can be processed concurrently, or they must be sequentially executed. Upon receiving state access requests, DB4NFV constructs one Task Precedence Graph (TPG) for each stage, where nodes symbolize state access operations and edges represent transactional dependencies. Dependencies are categorized as time-based (for operations accessing the same state object at different times), parametric (where one operation depends on another’s result), or logical (defining transaction boundaries). The TPG informs the allocation of workloads to parallel threads.

Once the TPG is constructed, DB4NFV allocates state access workloads to parallel threads. Given the highly dynamic and unpredictable nature of network traffic workload characteristics, DB4NFV adaptively selects the optimal task scheduling strategy from a pool of schedulers, aiming to fully optimize multicore resources and enhance overall system performance. The schedulers vary based on the graph exploration algorithms (BFS, DFS, Non-Structured), or whether to group multiple state access operations to trade off between improving scalability with fine-grained task allocation and reducing context-switching overhead. A heuristic decision model guides the selection of the optimal strategy based on multiple criteria, including the distribution of three types of dependencies, the skewness among state access operations, and an estimation of their computational complexities.

Support of VNF Modularization. DB4NFV also incorporates VNF modularization [3, 2, 17], segmenting VNF logic into discrete modules. Figure 4 illustrates applying modularization on the trojan detector and portscan detector, highlighting their common modular that can be reused to support both VNFs. During SFC declaration, DB4NFV allows users to define their VNFs in the form of collective VNF modular. Based on their functionalities and traffic dependencies, DB4NFV identifies and determines the feasibility of reusing modular components to support multiple VNFs in the chain, and generates an optimal modular placement strategy among instances. The placement strategy is determined so that different cores have minimum communications to support the collective execution of modular.

Caching of Infrequently Updated States. In scenarios where VNFs or specific network traffic patterns predominantly involve frequent Read operations on shared states with infrequent updates, DB4NFV implements a strategic caching mechanism. This approach is geared towards reducing redundant state accesses and minimizing packet processing delays. DB4NFV evaluates the ratio of Read requests against the total transaction batch. When the Read operations significantly outweigh updates, surpassing a predetermined threshold, DB4NFV enhances performance by caching these states in each thread’s local memory. This cached information is promptly synchronized with the central state upon any update to maintain consistency. In contrast, states experiencing a balanced or high ratio of updates are classified as frequently updated and are retained in the centralized datastore. Here, they are managed via DB4NFV’s transactional concurrency control mechanism, ensuring synchronized and efficient state access across the system.

Robustness in SFC execution is crucial, necessitating network states to be consistent despite execution failures or fluctuating network conditions. In DB4NFV, per-flow states, as well as states amenable to partitioning or infrequent shared access, are managed as local states within each instance’s memory for rapid access. Conversely, cross-flow states frequently accessed by multiple instances are centralized in a key-value database, with a state manager overseeing access.

Fault Tolerance Execution. DB4NFV ’s decoupled state management architecture enhances fault tolerance, effectively isolating failures within the job. To support this, DB4NFV utilizes multi-version state storage. State access executors update snapshots and transaction histories at regular intervals, laying the groundwork for quick state recovery post-failures. During operation, DB4NFV records interim results from dependency resolutions, including potential transaction aborts and parametric dependencies, where one state access hinges on another’s update. In the event of an instance failure, DB4NFV promptly identifies and halts all impacted state operations, guided by its dependency logs. It then reverts to the most recent stable state snapshot, ensuring the system’s consistency is preserved.

Robustness under Network Dynamics. The decoupled state management approach equips DB4NFV with the agility to uphold state consistency amidst diverse network conditions, while also ensuring scalability. Under regular operation, per-flow states are maintained within local memory for efficient access and modification. However, in response to dynamic network conditions necessitating state migration, these local states are temporarily shifted to the centralized database, becoming accessible shared resources for other relevant instances. For example, if a VNF is required to scale up due to a surge in network traffic, the per-flow states from existing instances are transferred to the centralized database. The state manager then reallocates these states among newly provisioned instances. Similarly, when a straggler VNF instance is detected, its local states are registered in the database and shared with a backup instance to ensure continuity. Upon completion of such migrations, the temporarily shared states are removed from the centralized database and reverted to their original locations in local memories. This method of state management fortifies the robustness of DB4NFV in handling network dynamics, seamlessly adapting to changing conditions without compromising system stability.