SFC Emulation: Modeling Network Service Chains

• Service Function Chain Emulation is a framework that models the deployment, orchestration, and operation of VNFs over programmable substrates to benchmark network services.
• It employs container-based virtualization and programmable networks like Mininet to simulate realistic conditions and measure performance metrics.
• The emulation platforms enable dynamic topology changes and resource allocation testing, capturing metrics such as end-to-end latency and CPU utilization.

A Service Function Chain (SFC) emulation system models the deployment, orchestration, and operation of network services realized via sequences of Virtual Network Functions (VNFs) over programmable substrates. SFC emulators establish a controlled environment wherein resource allocation algorithms, orchestration strategies, and runtime behaviors can be evaluated under configurable and high-fidelity conditions. They are essential for validating and benchmarking SFC management solutions, enabling measurement of performance metrics such as real CPU utilization, end-to-end latency, service acceptance ratio, and failure/migration effects. Contemporary SFC emulators integrate real containerized VNFs, programmable virtual networks (often based on Mininet/Containernet), telemetry, and flexible orchestrators inspired by ETSI NFV and IETF SFC architectures (Krishnamohan et al., 29 Jul 2025, Wang et al., 12 Dec 2025).

1. Architectural Foundations

Recent SFC emulators such as OpenRASE and Mini-SFC share key architectural components inspired by industry standards but tailored for research flexibility.

Table: Comparison of SFC Emulators

Emulation Platform	Substrate Virtualization	VNF Realization	Control Layer
OpenRASE	Mininet/Containernet	Docker-in-Docker VNFs	Ryu SDN Controller
Mini-SFC	Containernet/NetworkX	Docker containers, SimPy	Modular MANO modules

OpenRASE implements the ETSI NFV and IETF SFC reference architectures using a unified Python program: hosts are instantiated as Docker-in-Docker (DinD) containers within a Mininet-based topology, with each "host" capable of running multiple Docker-encapsulated VNFs. Forwarding is handled by Open vSwitch (OVS), with flows programmed by the Ryu controller via OpenFlow (Krishnamohan et al., 29 Jul 2025). Mini-SFC provides a layered design encompassing a user/API interface, simplified MANO (NFVO, VNFM, VIM, UEM) modules, and an event-driven core engine (SimPy-based), supporting both abstracted numerical simulation and container-based emulation modes (Wang et al., 12 Dec 2025).

2. Topology, Orchestration, and Emulation Modes

Topology generation in both systems is programmable and supports parameterized links (bandwidth, latency, loss). OpenRASE utilizes Mininet's Python API to construct substrate graphs, embedding containers as hosts and parameterizing link properties. The OpenRASE orchestrator programmatically deploys DinD containers, then launches Docker VNFs inside them. The VNF Manager applies resource limits (docker run --cpus=X --memory=Ym) (Krishnamohan et al., 29 Jul 2025).

Mini-SFC combines NetworkX for snapshot-based, time-variant topology graphs and Containernet for container-based node instantiation. By setting the use_container flag, researchers can toggle between:

• Discrete-event numerical simulation: Resource allocations tracked symbolically, constraints enforced via linear inequalities, and delays calculated via service and transmission models.
• Container-based emulation: Real Docker containers deployed on Containernet nodes, leveraging Open vSwitch for actual packet forwarding; performance metrics measured using real packet flows (HTTP, RPC), with resource control via Docker APIs (Wang et al., 12 Dec 2025).

Both platforms enable dynamic topology changes, supporting realistic failure, mobility, or infrastructure fluctuation scenarios. For example, Mini-SFC's Topo module manages time-indexed sequences of graphs, triggering migration/re-embedding events as topologies evolve.

3. Resource Allocation Models and Solver Frameworks

SFC emulators abstract the resource allocation (NFV-RA) and SFC embedding problem, providing solver interfaces for plug-and-play algorithmic experimentation. The Forwarding Graph Embedding (FGE) challenge is mathematically formalized using the following notation (Krishnamohan et al., 29 Jul 2025):

• $R$: set of SFC requests.
• $V_r$: ordered VNFs in chain $r$.
• $N$: substrate hosts.
• $c_n$, $m_n$: CPU, memory of host $n$.
• $d_{ij}$, $b_{ij}$: delay and bandwidth of link $(i,j)$.
• $V_r$0, $V_r$1: resource needs for VNF $V_r$2 in $V_r$3.
• $V_r$4: whether VNF $V_r$5 of $V_r$6 resides on $V_r$7.
• $V_r$8: whether link $V_r$9 is assigned for SFC path.
• $r$0: chain acceptance indicator.

Constraints enforce per-host and per-link capacity, path allocation, and placement feasibility. Objectives include maximizing acceptance ratio $r$1 or minimizing weighted sums of resource and latency costs.

Mini-SFC requires solvers to inherit from a standard base class, operating on the current substrate graph and SFC descriptor. The solver returns mapping/placement decisions, allowing rapid benchmarking of heuristics, integer programs, evolutionary algorithms, and migration-aware schemes (Wang et al., 12 Dec 2025).

4. Experimentation, Measurement, and Fidelity

Both OpenRASE and Mini-SFC support multi-layer telemetry capturing resource utilization, flow statistics, and application performance.

• In OpenRASE, CPU/memory are polled from Docker every second; sFlow-RT samples bandwidth from OVS; latency is measured via end-to-end HTTP requests generated by Grafana K6, carrying SFC IDs, with results imported into the telemetry database (Krishnamohan et al., 29 Jul 2025).
• Mini-SFC records CPU/RAM, link statistics, placement outcomes, and delay samples via its Trace module in both simulation and emulation modes (Wang et al., 12 Dec 2025).

Empirical findings illustrate the importance of emulation fidelity. For instance, OpenRASE captures genuine CPU contention and per-packet processing noise, with average HTTP RTTs under load ranging from 200–400 ms for static solvers, and CPU usage spikes on otherwise idle hosts reflecting realistic operational variance. Mini-SFC demonstrates that, under container-mode execution, CPU and memory utilization spike in response to real congestion or traffic imbalances—effects not visible in symbolic simulations.

Evaluation methods include controlled experiments varying CPU per host, SFC request volume, and solver type. Key metrics comprise acceptance ratio, deployment time, latency, and per-node resource profiles.

5. Online and Dynamic Adaptation

Service function chaining environments must support online, dynamic operation to reflect network variability and algorithmic responsiveness. OpenRASE implements an online Genetic Algorithm (GA) solver whose chromosome encodes the host placement for every VNF in all chains; fitness is measured directly via deployment in the emulated environment and observing acceptance ratio and HTTP latency (Krishnamohan et al., 29 Jul 2025). Tournament selection, single-point crossover, and mutation drive population updates.

Mini-SFC enables online dynamic topology changes using SimPy events; as new topologies are activated, active SFCs are reevaluated, with automatic migration or teardown as required. Solver runtime, embedding success, active SFC count, and resource/time metrics are tracked through topology transitions.

This capability is leveraged in case studies such as disaster-relief scenarios (SAGIN) where the infrastructure graph changes at 10-minute intervals with up to 48 nodes. The system supports resilience and reoptimization studies (Wang et al., 12 Dec 2025).

6. Limitations, Practical Insights, and Future Work

Despite high fidelity and flexibility, SFC emulators exhibit architectural and performance limitations:

• Scalability: Both platforms are constrained by the underlying host; experiments with $r$2 VNFs/containers show significant overhead due to container instantiation and scheduling.
• Execution time: Experiments involving full-scale emulation (e.g., online GA runs) can span hours or days due to the time required for container operations and in-situ measurements (Krishnamohan et al., 29 Jul 2025).
• Resource usage: Nested containerization (DinD + Docker + OVS) in OpenRASE and container mode in Mini-SFC are resource-intensive, limiting direct extrapolation to large-scale, real deployments.
• Integration burden: New VNFs must be delivered as container images with operational code, increasing development requirements relative to parameterized simulators.

Identified directions for future advancement include accelerating emulation (parallelized sub-topologies, container snapshots), integration with Kubernetes for distributed experiments, advanced traffic and queueing models (e.g., DCTCP, RED, priority queues), support for real VM-based NFV, and extensible solver frameworks incorporating multi-objective or ML/RL-based resource allocation (Krishnamohan et al., 29 Jul 2025, Wang et al., 12 Dec 2025).

7. Application Workflows and Research Utility

SFC emulation platforms enable researchers to conduct rapid prototyping and benchmarking of network orchestration and optimization methods. Typical workflows comprise programmatically defining substrate and service chain topologies, registering VNF/container templates, configuring user-traffic generators, selecting and configuring solvers, and initiating runtime execution. Both systems expose standardized APIs for declaring experiment parameters and collecting time-series telemetry.

Example in Mini-SFC (abridged for illustration):

$r$3 (Wang et al., 12 Dec 2025)

Collected traces yield detailed profiles of resource consumption, delays, solver performance, and embedding outcomes, supporting in-depth comparative evaluation across solvers, topology scenarios, and workload regimes.

---

References:

• "OpenRASE: Service Function Chain Emulation" (Krishnamohan et al., 29 Jul 2025)
• "Mini-SFC: A Comprehensive Simulation Framework for Orchestration and Management of Service Function Chains" (Wang et al., 12 Dec 2025)