Virne

Documentation | Citations | SDN-NFV Papers

Virne is a simulator designed to address resource allocation problems in network virtualization. This category of problems is often referred to by various names, including:

• Virtual Network Embedding (VNE)
• Virtual Network Function Placement (VNF Placement)
• Service Function Chain Deployment (SFC Deployment)
• Network Slicing

The main goal of Virne is to provide a unified and flexible framework for solving these problems. Its main characteristics are as follows.

• Rich Implementations: Provide 20+ solvers, including exact, heuristic, meta-heuristic, and machine learning-based algorithms.
• Extensible Development: Provide a variety of network topologies, network attributes, and RL environments, which can be easily extended.
• Light-Weight: Implement concisely with less necessary dependencies, and can be extended easily for specific algorithms.

Virne is still under development. If you have any questions, please open a new issue or contact me via email (wtfly2018@gmail.com)

• Completing the documentation
• Implementing more VNE algorithms

Citations

:sparkles: If you find Virne helpful to your research, please feel free to cite our related papers:heart:

[IJCAI, 2024] FlagVNE (paper & code)

@INPROCEEDINGS{ijcai-2024-flagvne,
  title={FlagVNE: A Flexible and Generalizable RL Framework for Network Resource Allocation},
  author={Wang, Tianfu and Fan, Qilin and Wang, Chao and Ding, Leilei and Yuan, Nicholas Jing and Xiong, Hui},
  booktitle={Proceedings of the 33rd International Joint Conference on Artificial Intelligence},
  year={2024},
}

[TSC, 2023] HRL-ACRA (paper & code)

@ARTICLE{tfwang-tsc-2023-hrl-acra,
  author={Wang, Tianfu and Shen, Li and Fan, Qilin and Xu, Tong and Liu, Tongliang and Xiong, Hui},
  journal={IEEE Transactions on Services Computing},
  title={Joint Admission Control and Resource Allocation of Virtual Network Embedding Via Hierarchical Deep Reinforcement Learning},
  volume={17},
  number={03},
  pages={1001--1015},
  year={2024},
  doi={10.1109/TSC.2023.3326539}
}

[ICC, 2021] DRL-SFCP (paper & code)

@INPROCEEDINGS{tfwang-icc-2021-drl-sfcp,
  author={Wang, Tianfu and Fan, Qilin and Li, Xiuhua and Zhang, Xu and Xiong, Qingyu and Fu, Shu and Gao, Min},
  booktitle={ICC 2021 - IEEE International Conference on Communications}, 
  title={DRL-SFCP: Adaptive Service Function Chains Placement with Deep Reinforcement Learning}, 
  year={2021},
  pages={1-6},
  doi={10.1109/ICC42927.2021.9500964}
}

Table of Contents

• Quick Start
  • Installation
  • Install with pip
  • Install with script
  • Minimal Example
• Supported Features
• Implemented Algorithms
  • Exact Algorithms
  • Heuristic Algorithms
  • Meta-Heuristic Algorithms
  • Learning-Based Algorithms

Quick Start

Installation

Install with pip

pip install virne

Install with script

# only cpu
bash install.sh -c 0

# use cuda (optional version: 10.2, 11.3)
bash install.sh -c 11.3

Minimal Example

from virne.base import BasicScenario
from virne import Config, REGISTRY, Generator, update_simulation_setting

def run(config):
    print(f"\n{'-' * 20}    Start     {'-' * 20}\n")
    # Load solver info: environment and solver class
    solver_info = REGISTRY.get(config.solver_name)
    Env, Solver = solver_info['env'], solver_info['solver']
    print(f'Use {config.solver_name} Solver (Type = {solver_info["type"]})...\n')

    scenario = BasicScenario.from_config(Env, Solver, config)
    scenario.run()

    print(f"\n{'-' * 20}   Complete   {'-' * 20}\n")

if __name__ == '__main__':
    config = Config(
        solver_name='nrm_rank',
        # p_net_setting_path='customized_p_net_setting_file_path',
        # v_sim_setting_path='customized_v_sim_setting_file_path',
    )
    Generator.generate_dataset(config, p_net=False, v_nets=False, save=False)
    run(config)

Supported Features

• Diverse Network Topologies for Simulation

  • Simple Network Structures: e.g. Star for Centralized Network, Path for Chain-style Network, etc.
  • Random Network Topologies: e.g. Waxman Graph, Edge Probabilistic Connection Graph, etc.
  • Real-world Network Topologies: e.g. Abilene, Geant, etc.

• Multiple level Attributes for QoS:

  • Graph Level: e.g. the global requirements of user service requests, etc.
  • Node level: e.g. computing resource, server position, energy consumption, etc.
  • Link level: e.g. bandwidth resource, communication delay, etc.

• Unified Reinforcement Learning Interface for Extension

  • Provide serval RL Environments in gym.Env-style.
  • Implement the many RL training algorithms, including MCTS, PPO, A2C, etc.
  • Support the integration of RL algorithms from other libraries.

• Various Simulation Scenarios

  • Admission control: Early Reject some not cost-effective service requests.
  • Cloud-Edge: Heteregenous infrastructure with different QoS provision.
  • Time window: Globally process the a batch service requests in a time window.

• Predefined QoS Awarenesses (Additional Constraints/ Objectives)

  • [x] Position (Node level)
  • [x] Latency (Graph, Node and Link level)
  • [x] Security (Graph, Node and Link level)
  • [ ] Congestion (Graph, Node and Link level)
  • [ ] Energy (Graph, Node and Link level)
  • [x] Reliability (Graph, Node and Link level)
  • [ ] Dynamic (Graph, Node and Link level)
  • [ ] Parallelization
  • [ ] Privacy

Implemented Algorithms

Virne has implemented the following heuristic-based and learning-based algorithms:

Mapping Strategies

• Two-Stage
  • In this fromework, the VNE solving process are composed of Node mapping and Edge Mapping.
  • Firstly, the node mapping solution is generate with node mapping algorithm, i.e., Node Ranking
  • Secondly, the BFS algorithm is employed to route the physical link pairs obtained from the node mapping solution.
• Joint Place and Route
  • The solution of node mapping consists of a sequential placement decision.
  • Simultaneously, the available physical link pairs are routed by BFS algorithm.
• BFS Trails
  • Based on breadth-first search, it expands the search space by exploiting the awareness of restarts.

Learning-based Solvers

* means that the algorithm only supports chain-shape virtual networks embedding

Meta-heuristics Solvers

Other Related Papers

• Particle Swarm Optimization
  • Xiang Cheng et al. "Virtual network embedding through topology awareness and optimization". CN, 2012.
  • An Song et al. "A Constructive Particle Swarm Optimizer for Virtual Network Embedding". TNSE, 2020.
• Genetic Algorithm
  • Liu Boyang et al. "Virtual Network Embedding Based on Hybrid Adaptive Genetic Algorithm" In ICCC, 2019.
  • Khoa T.D. Nguyen et al. "An Intelligent Parallel Algorithm for Online Virtual Network Embedding". In CITS, 2019.
  • Khoa Nguyen et al. "Efficient Virtual Network Embedding with Node Ranking and Intelligent Link Mapping". In CloudNet, 2020.
  • Khoa Nguyen et al. "Joint Node-Link Algorithm for Embedding Virtual Networks with Conciliation Strategy". In GLOBECOM, 2021.
• Ant Colony Optimization
  • N/A

Heuristics-based Solvers

Exact Solvers

Simple Baseline Solvers

To-do List

Environment Modeling

• [ ] ADD Scenario Window Batch Processing
• [x] ADD Environment Check Attributes of p_net and v_net
• [x] ADD Environment Latency Constraint
• [x] ADD Controller Check graph constraints
• [x] ADD Controller Multi-commodity flow
• [x] ADD Environment QoS level Constraints
• [x] ADD Recorder Count partial solutions' information
• [x] ADD Enironment Early rejection (Admission control)
• [x] ADD Environment Multi-Resources Attributes
• [x] ADD Environment Position Constraint
• [x] ADD Recorder Count Running physical network nodes

Algorithm Implementations