Virne Benchmark: NFV Resource Allocation

• Virne is a comprehensive open-source framework that models NFV resource allocation as an online VNE problem using deep RL, heuristics, and exact methods.
• The platform integrates a modular architecture with scenario generation, environment APIs, and an algorithm registry to support reproducible and scalable experiments.
• It supports diverse network scenarios—including cloud, edge, and 5G slicing—and provides actionable performance metrics like RAC, LRC, and AST for method comparison.

Virne is a comprehensive open-source benchmarking framework targeted at the evaluation and development of deep reinforcement learning (RL) methods for the network resource allocation (RA) problem in network function virtualization (NFV) environments. It provides an extensible simulation and evaluation platform to systematically compare diverse RL, heuristic, and exact algorithms on standardized cloud, edge, and 5G scenarios. With over 30 integrated methods and support for extensive configurability and metrics analysis, Virne addresses key research gaps in reproducible evaluation, generalization, and scalability for NFV-RA (Wang et al., 25 Jul 2025).

1. Formalization of the NFV Resource Allocation Problem

The NFV-RA task in Virne is formalized as an online virtual network embedding (VNE) problem, modeled as a finite-horizon Markov Decision Process (MDP). Each episode corresponds to mapping a virtual network function (VNF) request $\mathcal{G}_v$ onto a substrate (physical) network $\mathcal{G}_p$ while satisfying CPU, bandwidth, and scenario-specific constraints.

• State space ($\mathcal{S}$): Comprises the physical network topology and residual resources, the virtual network demand graph, and the partial mapping history.
• Action space ($\mathcal{A}$): At each step $t\le|\mathcal{N}_v|$, the agent selects a substrate node to host the next virtual node.
• Transition kernel ($P$): Proceeds only if placement succeeds (i.e., sufficient resources and valid routing); episodes terminate upon failure.
• Reward ($r$): Default scheme gives a positive intermediate reward for valid placements, a penalty for rejection, and a final reward proportional to the Revenue-to-Cost (R2C) ratio if the mapping is completed:

$$r(s_t, a_t) = \begin{cases} r_{\mathrm{step}}>0 & \text{if placement/routing succeeds at step } t\ -r_{\mathrm{step}} & \text{if placement fails (immediate reject)}\ 0 & \text{otherwise} \end{cases}$$

Final reward: $$r_\mathrm{final} = \varkappa \; \dfrac{\sum_{n_v} C(n_v) + \sum_{l_v} B(l_v)}{\sum_{n_v} C(n_v) + \sum_{l_v} B(l_v)\,|\,\rho_p(l_v)|}$$, with $\varkappa=1$ if mapping feasible.

• Termination: On full mapping or resource/latency violation.

This formalization enables principled RL algorithm development and fair metric computation across arbitrary topologies and demand distributions.

2. Framework Architecture and Experiment Pipeline

Virne is architected into four core modules that orchestrate scenario creation, simulation, algorithm deployment, and evaluation:

Module	Purpose	Example Functionality
Scenario Generator	Configures environments with YAML	Cloud/edge/5G topology, resource, arrival model
Environment API	Event-driven Gym-like interface	State, action, reward, step, reset
Algorithm Registry	Library of 30+ RL, heuristic, planning methods	DQN, PPO, MCTS, GRC, PSO, GA, etc.
Evaluation Module	Computes core and extended metrics	Acceptance rate, LRC, solving time, curves

The platform flows through five experimental phases: scenario configuration, agent selection and instantiation, episodic simulation with online RL or batch inference, detailed per-episode logging, and automatic statistical post-processing and visualization. This modularity supports extensibility and reproducibility across research groups.

3. Supported Network Scenarios and Configurability

Virne enables rapid prototyping of RA methods under a range of networking conditions through scenario templates:

• Cloud: Standard data center or backbone topologies (WX100, GEANT, BRAIN), Poisson VNF arrivals, no extra end-to-end constraints.
• Edge: Reduced arrival intensity, additional max end-to-end latency (≤100ms), more stringent lifetime distributions.
• 5G Slicing: Supports slice isolation, security constraints, and variable topology overlays.

Table: Key scenario configuration fields (Wang et al., 25 Jul 2025)

Parameter	Cloud	Edge	5G Slicing
Topology	WX100, GEANT, BRAIN	WX100 (lower $\mathcal{G}_p$0)	GEANT (slice graphs)
Arrival Model	Poisson($\mathcal{G}_p$1)	Poisson($\mathcal{G}_p$2/2)	Poisson($\mathcal{G}_p$3)
VN size	$\mathcal{G}_p$4	$\mathcal{G}_p$5	$\mathcal{G}_p$6 + isolation
Constraints	None	Max-latency	Security levels

All scenario and resource parameters are exposed in the YAML configuration, allowing researchers to customize topologies, arrival processes, resource types (CPU, bandwidth, latency, energy), and multi-objective constraints.

4. Integrated Methods and Algorithmic Scope

Virne incorporates an extensive suite of resource allocation and VNE algorithms:

• Value-based RL: DQN.
• Policy-gradient/Actor–Critic: REINFORCE, PPO, A3C, TRPO with multiple backbone variants (e.g., MLP, attention, graph networks).
• Graph RL: Dual-GAT, Dual-GCN architectures encoding both VN and PN.
• Planning: MCTS (Monte Carlo Tree Search).
• Heuristic Baselines: Greedy ranking (GRC), NRM, NEA, random walk, population-based metaheuristics (GA, PSO, ACO, SA, TS).
• Exact/Relaxed Rounding: MIP, R-rounding, D-rounding.

Default hyperparameters are scenario-tuned and method-specific, with all values accessible and overrideable in code. Calling any method by registry instantiates it with the appropriate settings for reproducible comparison.

5. Evaluation Metrics and Practicality Perspectives

Virne systematically measures both traditional performance indicators and broader practical aspects:

• Request Acceptance Rate (RAC):

$\mathcal{G}_p$7

• Long-Term Revenue-to-Cost (LRC):

$\mathcal{G}_p$8

• Long-Term Average Revenue (LAR):

$\mathcal{G}_p$9

• Solving time (AST): Average CPU time per instance.

Practical evaluation includes:

• Solvability: Distribution of R2C across varying VN sizes, supporting offline mapping analysis.
• Generalization: Metrics under varying traffic rates or unseen topologies.
• Scalability: RAC/LRC/AST as substrate and virtual network sizes are scaled up.

6. Experimental Findings and Insights

Empirical results with Virne show that:

• Dual-graph neural RL (PPO-DualGAT, PPO-DualGCN) achieves the highest RAC (≈78%), LRC (≈0.74), and maintains robustness under load and across topologies.
• Classical feedforward RL (PPO-MLP, PPO-ATT) is competitive (RAC ≈71%) but consistently outperformed by graph-based approaches.
• Planning (MCTS): High RAC for small instances, but suffers from solving times >3s instance$\mathcal{S}$0 compared with RL inference <0.2s.
• Heuristics: Fast (≈0.01s), but with lower RAC (≈60%) and LRC (≈0.56).
• Scalability: On WX500 (500-node substrate), PPO-DualGAT sustains high performance (RAC ≈70%, LRC ≈0.71, AST ≈5s); metaheuristics become intractable ($\mathcal{S}$115s).

Secondary insights include:

• Reward shaping (intermediate + final R2C) accelerates RL convergence versus sparse rewards.
• Action masking and the use of both topological and status features give a 5–7pp boost in RAC.
• For strict resource or latency settings, further advances (e.g., HeteroGAT, constrained RL) are indicated.
• Training with curriculum learning improves generalization for shifting demand regimes.

7. Limitations and Research Directions

Virne identifies prominent research challenges and proposes next-step methodologies:

• Improved cross-graph representation learning for encoding mappings and path constraints.
• Constrained (safe) RL frameworks ensuring strict adherence to latency, energy, or isolation requirements.
• Scalable non-autoregressive or hierarchical policies for carrier-grade substrate sizes.
• Meta-RL and domain-randomization for policy generality across unseen environments and stochastic loads.

Practical limitations include the computational cost of metaheuristics at scale, the need for further optimization under multi-dimensional resource constraints, and ongoing work to standardize benchmarking across new traffic models.

---

Virne standardizes the empirical evaluation of RL and algorithmic approaches for NFV resource allocation, exposes actionable performance trade-offs, and offers a unified testbed for future research into scalable, robust, and generalizable network resource management methods (Wang et al., 25 Jul 2025).