#
**Authors**: Ryan McCann, Arash Rezaee, Vinod M. Vokkarane, Electrical and Computer Engineering Department, University of Massachusetts Lowell, United States, Both authors contributed equally to this work.
> ryan_mccann@student.uml.edu
> arash_rezaee@student.uml.edu
> vinod_vokkarane@uml.edu
FUSION: A Flexible Unified Simulator for Intelligent Optical Networking thanks: This paper was partially supported by NSF project award #2008530.
Abstract
The increasing demand for flexible and efficient optical networks has led to the development of Software-Defined Elastic Optical Networks (SD-EONs). These networks leverage the programmability of Software-Defined Networking (SDN) and the adaptability of Elastic Optical Networks (EONs) to optimize network performance under dynamic traffic conditions. However, existing simulation tools often fall short in terms of transparency, flexibility, and advanced functionality, limiting their utility in cutting-edge research. In this paper, we present a Flexible Unified Simulator for Intelligent Optical Networking (FUSION), a fully open-source simulator designed to address these limitations and provide a comprehensive platform for SD-EON research. FUSION integrates traditional routing and spectrum assignment algorithms with advanced machine learning and reinforcement learning techniques, including support for the Stable Baselines 3 library. The simulator also offers robust unit testing, a fully functional Graphical User Interface (GUI), and extensive documentation to ensure usability and reliability. Performance evaluations demonstrate the effectiveness of FUSION in modeling complex network scenarios, showcasing its potential as a powerful tool for advancing SD-EON research.
Index Terms: Software-Defined Optical Networks (SDONs), Optical Network Simulation, Reinforcement Learning, Machine Learning, Open-Source
I Introduction
The increasing global demand for internet services has driven the need for advanced communication networks that can adapt to growing data volumes and dynamic traffic patterns [1]. Elastic Optical Networks (EONs) have emerged as a key technology, offering flexible bandwidth allocation and improved spectral efficiency to meet these demands. Optical networking, which forms the backbone of modern telecommunications, traditionally relies on fixed Wavelength Division Multiplexing (WDM) systems. However, the rigid nature of WDM has led to the development of EONs, which provide a more adaptable approach to spectrum management [2]. With the advent of Software Defined Networking (SDN), the capabilities of EONs have been enhanced, giving rise to Software Defined Elastic Optical Networks (SD-EONs), which enable more dynamic and efficient network configurations [3].
Despite the importance of SD-EONs, the research community lacks a comprehensive, open-source simulator for rigorous testing and development in this field. Existing simulators often fall short in areas such as transparency, flexibility, and advanced functionality. Many remain closed-source, limiting their adoption and trustworthiness. This gap highlights the need for a high-quality, open-source SD-EON simulator.
The primary objective of this paper is to present the development of a fully open-source software defined elastic optical networking simulator. This simulator is designed to meet current research needs and offer features lacking in other tools, including thorough unit testing, detailed documentation, and integration with modern machine learning frameworks such as Reinforcement Learning (RL), with support for the Stable Baselines 3 library [4, 5]. Additionally, the simulator includes a fully functional Graphical User Interface (GUI) and advanced output capabilities, such as data export in multiple formats. By maintaining a rigorous software development pipeline and fostering community contributions, this simulator aims to set a new standard in SD-EON research.
The paper is structured as follows: Section II reviews existing optical network simulators. Section III outlines the system architecture of the proposed simulator. Section IV details the simulator’s functionality and validation setups. Section V presents the performance evaluation. Finally, Section VI concludes the paper and discusses future research directions.
II Literature Review
Software Defined Optical Networks (SDONs) represent a significant evolution in the field of optical networking, combining the flexibility of Elastic Optical Networks (EONs) with the programmability of Software Defined Networking (SDN). EONs enable dynamic spectrum allocation, optimizing the use of available resources to accommodate varying traffic demands [2]. When integrated with SDN, these networks benefit from centralized control, allowing for more efficient network management and adaptability in response to real-time changes [3].
Several simulators have been developed to model and evaluate the performance of SDONs, each offering distinct features and functionalities. These tools are crucial for advancing research in the field, enabling the exploration of new algorithms and network configurations under controlled conditions. Among these, Optical RL-Gym stands out for its integration with the Stable Baselines 3 library, providing a comprehensive platform for RL experiments in optical networks [6]. It offers a variety of custom environments tailored for Deep RL, such as DeepRMSA, which is an adapted version of a previously published routing and spectrum assignment (RSA) algorithm [7]. Optical RL-Gym also includes documentation and tests that facilitate the creation and use of custom environments, although the level of detail in these resources varies. The simulator is fully open-source, making it accessible for modification and extension by researchers.
OMNeT++ is a modular discrete-event simulation framework widely used in networking research, including optical networks [8]. Its strength lies in its extensibility and the large ecosystem of models like INET for various network types. OMNeT++ offers a user-friendly GUI for simulation setup and analysis, making it easier to configure network scenarios and monitor performance metrics. While the framework is open-source, some specialized modules require licensing, which can limit accessibility. Despite its steep learning curve, OMNeT++ is popular for its flexibility and strong community support.
SimTON, another prominent simulator, focuses on providing highly customizable simulation parameters, particularly for physical layer aspects like input power, gain factor, and the residual dispersion parameter [9]. It features a robust GUI that supports topology visualization and allows users to interact with nodes and links to access detailed information. SimTON’s detailed physical layer assumptions and the ease of adjusting optical components such as switches, amplifiers, and fibers make it a powerful tool for simulating complex optical networks.
SimEON offers a different set of capabilities, particularly in modeling physical impairments, dynamic traffic, and energy consumption within optical networks [10]. It supports regenerator-aware algorithms alongside traditional routing and spectrum assignment (RSA) methods and leverages parallel processing to enhance simulation efficiency. While SimEON claims to be fully open-source, access to the code is currently limited, posing challenges for broader adoption in the research community.
Despite the advancements these simulators offer, their features have been considered but are not sufficient for comprehensive research needs. While numerous other simulators exist in the field, such as [11] and [12], they were not highlighted due to their limited scope or inability to address the full range of functionalities required for advanced SDON research. While the simulators discussed above provide valuable tools for certain aspects of SDON research, they lack several critical features necessary for a truly comprehensive simulation environment. These include robust unit testing for ensuring simulation quality, detailed and standardized documentation for setup and assumptions, and support for high-performance computing clusters. Furthermore, essential functionalities like GitHub pipelines for quality control, standardized guidelines, multi-processing support, and configuration files are often incomplete or entirely absent. The absence of these features limits the applicability of these simulators for more rigorous research and highlights the need for a more robust, all-encompassing Flexible Unified Simulator for Intelligent Optical Networking (FUSION).
This gap underscores the necessity for a new simulator that not only integrates these missing functionalities but also sets a higher standard for the research community. By offering a fully open-source, high-quality platform that addresses the limitations of existing tools, this new simulator aims to drive innovation and support the growing demands of SDON research.
III System Architecture
The system architecture of our Python-based SDON simulator (FUSION) is designed to be modular and flexible, accommodating a range of simulation types, including those driven by RL, supervised learning (SL), and traditional non-AI methods [13]. At the core of this architecture are the core scripts, which manage essential operations such as request generation, routing, spectrum assignment, and quality of transmission. These core components are coordinated by the central engine script, as illustrated in Figure 1.
Simulation Start (GUI/Non-GUI)
Standard
SL
RL
Core Scripts
Independent Modules
Figure 1: High-level design of the FUSION architecture.
Users have the flexibility to run simulations either through a GUI or by directly utilizing configuration files. The GUI enhances usability by providing a text editor, the ability to view and select various topologies, configure simulation parameters, and execute simulations. A screenshot of the GUI is shown in Figure 2.
<details>
<summary>2410.13999v2/extracted/6164171/figures/gui_screenshot.png Details</summary>
### Visual Description
# Technical Document Extraction
## File Explorer Structure
### Folders
- `__pycache__`
- `arg_scripts`
- `bash_scripts`
- `config_scripts`
- `data`
- `data_scripts`
- `docs`
- `excel_scripts`
- `gui_scripts`
- `helper_scripts`
- `ini`
- `logs`
- `plot_scripts`
- `sb3_scripts`
- `sim_scripts`
- `src`
- `tests`
- `venv`
- `venvs`
### Files
- `CODE_OF...`
- `CONTRIBUT...`
- `LICENSE`
- `README.md`
- `requirement...`
- `run_gui.py`
- `run_ml_sim.py`
- `run_rl_sim.py`
- `run_sim.py`
## Network Diagram Analysis
### Diagram Title
- **Topology View**
### Node Structure
- **Nodes**: 24 (numbered 0–23)
- **Connections**: Bidirectional edges between nodes
- **Visual Representation**: Blue circles with white numbers
### Node Connections
```mermaid
graph LR
0 --> 1
0 --> 5
1 --> 3
1 --> 5
2 --> 3
2 --> 6
3 --> 4
3 --> 6
4 --> 7
5 --> 6
5 --> 8
6 --> 7
6 --> 8
7 --> 9
8 --> 10
8 --> 11
9 --> 12
10 --> 11
10 --> 14
10 --> 18
11 --> 12
11 --> 15
12 --> 13
12 --> 16
13 --> 17
14 --> 15
14 --> 19
15 --> 16
15 --> 20
16 --> 17
16 --> 21
17 --> 22
17 --> 23
18 --> 19
19 --> 20
20 --> 21
21 --> 22
22 --> 23
```
### Legend
- **Node**: Blue circle with white number
### Interface Elements
- **Tabs**:
- `File Editor` (inactive)
- `Topology View` (active)
- **Background**: White
## Key Observations
1. The network diagram represents a complex interconnected system with 24 nodes.
2. Nodes are organized in a grid-like pattern with dense local connections and sparser global links.
3. The file explorer suggests a Python-based project structure with script directories and configuration files.
4. The presence of `venv` and `venvs` indicates virtual environment management.
5. The `README.md` and `LICENSE` files suggest standard open-source project documentation.
</details>
Figure 2: FUSION GUI displaying the USNet Topology.
The helper scripts module plays a crucial role in organizing utility functions that are essential across the simulator, including statistical calculations and data export in formats like CSV, Excel, or JSON. For visual analysis, the plot scripts module generates detailed visual outputs from simulation data, assisting users in interpreting and analyzing results effectively. Additionally, the simulator integrates with advanced RL libraries such as Stable Baselines 3 (SB3), RLZoo3, and Gymnasium through the SB3 scripts module, enabling sophisticated AI-driven simulations.
Data management within the simulator is handled by the data scripts module, which oversees data generation and output, particularly to Excel. The configuration scripts module ensures that simulation input parameters are correctly structured and managed, whether running single or multi-processed simulations. For high-performance computing (HPC) environments, the bash scripts directory supports essential tasks such as creating environments, checking job priorities, submitting and managing jobs, and monitoring memory usage via a Slurm job scheduler. The argument scripts module centralizes all simulation run arguments, ensuring consistency and ease of configuration.
To maintain high quality and reliability, the simulator includes a robust tests module. This module is responsible for testing all other modules and scripts, ensuring that they function correctly and efficiently. We ensure 90% unit testing coverage to guarantee the thoroughness of the tests, which are critical to maintaining the integrity of the simulator, especially when integrating new features or updates.
Documentation is automatically generated using Sphinx and is stored in the documents directory. This documentation includes comprehensive guides and references for users, ensuring they have the necessary information to effectively utilize the simulator.
Table I provides an overview of the modules and directories within the FUSION simulator, summarizing their primary functionalities.
| Core Scripts | Manages engine, routing, and SDN |
| --- | --- |
| Helper Scripts | Utilities for stats, data export |
| Plot Scripts | Visual output generation |
| SB3 Scripts | Connects RL libraries |
| Tests | Unit tests for components |
| Data Scripts | Data generation |
| Statistical Helpers | Exports stats (CSV, Excel, JSON) |
| Documents | Sphinx documentation |
| Configuration Scripts | Simulation input setup |
| Bash Scripts | HPC tasks, job management |
| Argument Scripts | Centralized simulation arguments |
| GitHub Workflows | Continuous Integration automation |
| Miscellaneous Files | Licenses, guidelines |
TABLE I: Overview of Modules and Directories
The simulator is built using Python and leverages various libraries tailored to artificial intelligence and data processing, such as scikit-learn for SL and Stable Baselines 3 for RL. This technology stack facilitates the integration of sophisticated AI algorithms while maintaining high performance and scalability.
In summary, the system architecture of our simulator is designed to be modular, flexible, and extensible, ensuring that all components work together efficiently while allowing for the easy addition of new features. The core scripts handle the simulator’s central operations, while auxiliary modules and directories add functionality and support, making the simulator a powerful tool for optical network research and development.
IV Methodology
The simulation process in FUSION is highly configurable, allowing users to tailor the simulation environment to their specific needs. The configuration file provides a comprehensive interface to modify various parameters, particularly in relation to crosstalk-aware (XT-aware) algorithms, SL algorithms, and RL algorithms. The user can also select traditional routing and spectrum assignment algorithms, offering flexibility in how the simulations are conducted.
FUSION supports a variety of network topologies, allowing users to simulate different network environments. The topologies currently supported include the Dutch Telecom (DT), United States (US), Pan-European, and the National Science Foundation (NSF) networks. Traffic requests in the simulator are generated using random distributions: source and destination nodes are selected using a uniform distribution, while the arrival and holding times are modeled with an exponential distribution. These configurations provide a realistic simulation environment that can be tailored to explore a variety of scenarios.
IV-A Algorithms and Techniques
FUSION implements a diverse set of algorithms, each designed to address specific challenges in optical network management.
IV-A 1 Standard Routing and Spectrum Assignment Algorithms
Users can select from traditional Routing and Spectrum Assignment (RSA) algorithms to simulate network scenarios under various conditions. For routing, the simulator supports algorithms such as k-shortest path (KSP) and shortest path (SP). For spectrum assignment, users can choose from first-fit (FF), best-fit (BF), and last-fit (LF) algorithms. These traditional algorithms provide a baseline for comparison against more advanced techniques, enabling users to explore different strategies for optimizing network performance.
IV-A 2 Crosstalk-Aware Algorithms
The inter-core crosstalk (XT) aware algorithm in the simulator allows users to model real-world XT interference scenarios during spectrum assignment. By carefully selecting channels to minimize the impact of XT, users can simulate and evaluate the effects of XT on network performance. This feature is particularly useful for exploring how different levels of XT might affect the quality of transmission and for optimizing channel assignments to mitigate interference. The theoretical basis for this algorithm involves calculating potential XT levels and selecting routes that minimize these levels. The relevant theoretical equations for calculating XT for slot $s$ of core $c$ on path $P$ are as follows:
$$
XT\left(P,c,s\right)=\sum\limits_{{e}\in{P}}\sum\limits_{{c^{\prime}}\in{A_{e,%
c,s}}}\frac{{1-\exp\left({-2\cdot h\cdot L\left(e\right)}\right)}}{{1+\exp%
\left({-2\cdot h\cdot L\left(e\right)}\right)}}, \tag{1}
$$
where $L\left(e\right)$ , $h$ , and $A_{c,e}$ represent link length, power coupling coefficient, and the list of adjacent cores with active overlapping slots for slot $s$ of core $c$ on link $e$ , respectively. This equation allows the simulator to quantify and minimize XT during resource allocation [14].
IV-A 3 Reinforcement Learning Algorithms
For RL, the simulator integrates a range of algorithms, including Q-learning, epsilon-greedy bandit, and Upper Confidence Bound (UCB) bandit. These RL algorithms can be applied to both routing and spectrum assignment decisions, allowing the simulator to dynamically optimize network performance.
The Q-learning algorithm is based on the following update equation:
$$
Q(s,a)\leftarrow Q(s,a)+\alpha\left[r+\gamma\max_{a^{\prime}}Q(s^{\prime},a^{%
\prime})-Q(s,a)\right] \tag{2}
$$
where $Q(s,a)$ is the value of taking action $a$ in state $s$ , $\alpha$ is the learning rate, $r$ is the reward, $\gamma$ is the discount factor, $s^{\prime}$ is the next state that the agent transitions to after taking action $a$ , and $\max_{a^{\prime}}Q(s^{\prime},a^{\prime})$ represents the maximum Q-value over all possible actions $a^{\prime}$ in the next state $s^{\prime}$ .
This equation governs how the Q-learning algorithm updates its knowledge based on the environment’s feedback.
The epsilon-greedy bandit algorithm, which balances exploration and exploitation, follows this selection strategy:
$$
a=\begin{cases}\text{random action},&\text{with probability }\epsilon\\
\max_{a}Q(s,a),&\text{with probability }1-\epsilon\end{cases} \tag{3}
$$
where $\epsilon$ is the probability of choosing a random action, allowing the agent to explore the action space while also exploiting the current knowledge.
The Upper Confidence Bound (UCB) bandit algorithm is designed to select actions that maximize the upper confidence bound of the expected reward. The action selection strategy for UCB is given by:
$$
a_{t}=\arg\max_{a}\left[\hat{\mu}_{a}+c\sqrt{\frac{2\log t}{n_{a}}}\right] \tag{4}
$$
where $\hat{\mu}_{a}$ is the estimated mean reward of action $a$ , $c$ is a confidence level parameter, $t$ is the current time step, and $n_{a}$ is the number of times action $a$ has been selected. This equation balances exploration and exploitation by considering both the expected reward and the uncertainty in the estimates.
In addition to these custom RL algorithms, FUSION includes support for all algorithms available in the Stable Baselines 3 library. This integration provides users with access to a wide range of state-of-the-art Deep-RL techniques, such as Asynchronous Advantage Actor Critic (A3C), Deep Q Network (DQN), and Proximal Policy Optimization (PPO), further enhancing the simulator’s capability to optimize network performance in various scenarios.
IV-A 4 Supervised Learning Algorithms
In addition to RL, the simulator includes SL algorithms such as the decision tree classifier. This algorithm can be used as a classifier for routing and spectrum assignment, enabling the simulation of different routing strategies based on classification of network states. The decision tree algorithm works by recursively partitioning the data space based on the features that provide the highest information gain or Gini impurity reduction. The algorithm’s decision-making process is governed by the following equation for information gain:
$$
IG(D,A)=H(D)-\sum_{v\in\text{values}(A)}\frac{|D_{v}|}{|D|}H(D_{v}) \tag{5}
$$
where $IG(D,A)$ is the information gain of attribute $A$ with respect to dataset $D$ , and $H(D)$ is the entropy of the dataset $D$ . This equation determines how the decision tree splits the data at each node, which can be applied to optimize routing decisions based on network conditions.
Additionally, users can incorporate other supervised and unsupervised learning algorithms from the scikit-learn library if they wish to implement alternative or more complex classifiers. Examples of such algorithms include Support Vector Machines (SVM), Random Forest, and K-Nearest Neighbors (KNN). This flexibility allows users to explore a wide range of SL techniques for optimizing routing and spectrum assignment in FUSION.
IV-B Comparison and Validation
To ensure reliable and accurate simulations, FUSION includes extensive validation and testing procedures, with 90% unit testing coverage across all modules. These tests focus on validating the critical algorithms and techniques, particularly when integrating new features or updates. The robust testing framework ensures the simulator functions as expected under various configurations and scenarios.
A key strength of the simulator lies in its extensive feature set, which surpasses that of other available simulators. Table II highlights these key features in comparison with other prominent optical network simulators, demonstrating that FUSION offers a broader range of capabilities. The simulator excels in areas critical to modern optical network research, such as crosstalk awareness, RL, support for multi-core optical fibers, multi-band support for spectrum assignment, and high-performance computing integration. These unique features make the simulator a powerful tool for both academic research and practical applications in the field of optical networks.
| Feature | FUSION | Optical RL-Gym | SimTON | SimEON | OMNeT++ |
| --- | --- | --- | --- | --- | --- |
| Artificial Intelligence | | | | | |
| Reinforcement Learning | X | | | | |
| Deep Reinforcement Learning | X | X | | | |
| Supervised Learning | X | | | | |
| Network Modeling | | | | | |
| Physical Impairment Modeling | X | X | X | X | X |
| Multi-Band Support | X | X | | | |
| Multi-Core Fibers | X | X | | | X |
| Multi-Processed Simulations | X | | | X | X |
| Usability and Development | | | | | |
| Graphical User Interface | X | | X | | X |
| Unit Test Coverage | X | X | | | |
| Documentation and Tutorials | X | X | | | X |
| Continuous Integration Pipelines | X | | | | |
| Licensing and Output | | | | | |
| Open-Source | X | X | X | X | X |
| Plotting | X | X | X | X | X |
| Custom Result Output | X | | | | |
TABLE II: Comparison of Features Between FUSION and Other Optical Network Simulators
V Performance Evaluation
This section evaluates the performance of the proposed simulator by analyzing three key aspects: light segment slicing, XT-aware, and RL-based algorithms. The evaluations demonstrate the simulator’s capability in reducing blocking probability and optimizing network performance. The results are presented through comparative analysis, highlighting the effectiveness of advanced slicing techniques and other innovative methods.
V-A Light Segment Slicing
The Light Segment Slicing (LSS) method introduces a segmentation mechanism that divides light paths into multiple segments, enhancing spectrum utilization and reducing blocking probability. Simulations were conducted on the USNet topology with 4 cores, allowing 1 (KSP-FF), 2, and 8 segments. Fig. 3 shows that as the number of segments increases, blocking probability decreases significantly, particularly with 8 segments at earlier traffic volumes. This approach demonstrates a clear improvement in network performance, making LSS an effective strategy for optimizing optical networks. For more details, refer to [15].
$50$
$100$
$200$
$300$
$400$
$500$ $10^{-2}$ $10^{-1}$ $10^{0}$ Normalized Network Load [Erlang per Core] Average Blocking Probability KSP-FF $k=3$ LSS = 2 LSS = 8
Figure 3: BP vs. Load for Light-Segment Slicing.
V-B XT-Aware Algorithms
The XT-aware bandwidth-slicing modulation, core, and spectrum assignment (XTA-SMCSA) method integrates a light-segment slicing approach with the prioritized core and first-fit spectrum allocation algorithms, along with precise link-based XT calculations, to overcome the fragmentation issue, XT, and amplified spontaneous emission (ASE) noises simultaneously. Fig. 4 illustrates the request blocking probability of the XT-aware routing (XTAR) and KSP ( $k$ = 1 (1SP) and $k$ = 3 (3SP)) routing algorithms along with XTA-SMCSA method and a maximum allowed slices of 8 compared to 1SP and 3SP with first fit core and spectrum allocation (1SP-FF and 3SP-FF) with precise link-based XT calculation versus normalized network load. These previously published results, obtained using the simulator, demonstrate that the implementation of the slicing approach significantly reduces the blocking probability, resulting in no requests being blocked at 50 Erlang. Additionally, incorporating XTAR with XTA-SMCSA, considering Policy I for $\alpha=0$ ( $\pi_{1}(0)$ ), outperforms both other approaches, completely eliminating the blocking probability up to 200 Erlangs. For more details, refer to [14].
$100$
$200$
$300$
$400$
$500$ $10^{-3}$ $10^{-2}$ $10^{-1}$ $10^{0}$ Normalized Network Load [Erlang per Core] Average Blocking Probability 1SP-FF 3SP-FF SP-XTA-SMCSA-8 3SP-XTA-SMCSA-8 XTAR- $\pi_{1}$ (0)
Figure 4: BP vs. Load for XTAR & XTA-SMCSA.
V-C Reinforcement Learning-Based Path Selection
The path selection performance of different RL algorithms, namely Q-learning, epsilon-greedy bandit, and UCB bandit, is evaluated against traditional routing methods such as SPF-FF and KSP-FF (with $k=4$ ). Fig. 5 presents the average blocking probability versus episodes for these algorithms under a network load of 750 Erlangs. The results indicate that R-based methods significantly outperform traditional algorithms in reducing blocking probability, particularly in the latter episodes where the algorithms have learned effective routing strategies. Q-learning, in particular, demonstrates the lowest blocking probability across all methods, capitalizing on its ability to dynamically adapt to varying network conditions. The epsilon-greedy bandit also shows robust performance, especially in the initial episodes, due to its balanced exploration and exploitation strategy. $0 0$ $20$ $40$ $60$ $80$ $100$ $0.050$ $0.100$ $0.150$ Episodes [Simulation Runs] Average Blocking Probability Q-Learning Epsilon-Greedy Bandit UCB Bandit SPF-FF KSP-FF $k=4$
Figure 5: BP vs. Episodes for 750 Erlang.
VI Conclusion
FUSION is a comprehensive, open-source optical network simulator that addresses gaps in existing tools by supporting both traditional and advanced machine learning and RL techniques. It enables researchers to explore and optimize a wide range of network scenarios with a user-friendly interface and thorough testing framework. Performance evaluations show FUSION’s accuracy in modeling complex SDON environments, highlighting its potential to drive innovation in optical network research. Future work will expand its capabilities, including new machine learning models and multi-band/multi-core fiber support for emerging technologies.
References
- [1] Cisco, “Cisco annual internet report (2018–2023) white paper,” 2023. [Online]. Available: https://bit.ly/cisco-report-2020
- [2] O. Gerstel, M. Jinno, A. Lord, and S. B. Yoo, “Elastic optical networking: a new dawn for the optical layer?” IEEE Communications Magazine, vol. 50, no. 2, pp. s12–s20, 2012.
- [3] K. Nisar, E. R. Jimson, M. H. A. Hijazi, I. Welch, R. Hassan, A. H. M. Aman, A. H. Sodhro, S. Pirbhulal, and S. Khan, “A survey on the architecture, application, and security of software defined networking: Challenges and open issues,” Internet of Things, vol. 12, p. 100289, 2020. [Online]. Available: https://www.sciencedirect.com/science/article/pii/S2542660520301219
- [4] F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay, “Scikit-learn: Machine learning in python,” Journal of Machine Learning Research, vol. 12, pp. 2825–2830, 2011.
- [5] A. Raffin, A. Hill, M. Ernestus, A. Gleave, A. Kanervisto, and N. Dormann, “Stable Baselines3,” https://github.com/DLR-RM/stable-baselines3, 2021, gitHub repository.
- [6] C. Natalino and P. Monti, “The Optical RL-Gym: An open-source toolkit for applying reinforcement learning in optical networks,” in 2020 22nd International Conference on Transparent Optical Networks (ICTON). Bari, Italy: IEEE, 2020, pp. 1–4.
- [7] X. Chen, B. Li, R. Proietti, H. Lu, Z. Zhu, and S. J. B. Yoo, “DeepRMSA: A Deep Reinforcement Learning Framework for Routing, Modulation and Spectrum Assignment in Elastic Optical Networks,” Journal of Lightwave Technology, vol. 37, no. 16, pp. 4155–4163, 2019.
- [8] Andras Varga and OpenSim Ltd., OMNeT++ User Manual, OpenSim Ltd., 2021, https://omnetpp.org/documentation/.
- [9] D. A. R. Chaves, H. A. Pereira, C. Bastos-Filho, and J. F. M. Filho, “SIMTON: A Simulator for Transparent Optical Networks,” Journal of Communication and Information Systems, vol. 25, no. 1, pp. 1–10, 2010.
- [10] M. A. Cavalcante, H. A. Pereira, and R. C. Almeida, “SimEON: an open-source elastic optical network simulator for academic and industrial purposes,” Photonic Network Communications, vol. 34, no. 2, pp. 193–201, 2017.
- [11] B. Hu, M. J. Majid, and B. Ramamurthy, “Dynamic network simulation using DeepRMSA in Elastic Optical Networks,” in 2022 IEEE International Conference on Advanced Networks and Telecommunications Systems (ANTS). Gandhinagar, Gujarat, India: IEEE, 2022.
- [12] M. Aibin and M. Blazejewski, “Complex Elastic Optical Network Simulator (CEONS),” in 2015 17th International Conference on Transparent Optical Networks (ICTON). Budapest, Hungary: IEEE, 2015.
- [13] A. Rezaee, R. McCann, K. Bempah, and V. Vokkarane, “FUSION: A Flexible Unified Simulator for Intelligent Optical Networking,” https://github.com/SDNNetSim/FUSION, 2024.
- [14] A. Rezaee, R. McCann, and V. M. Vokkarane, “Dynamic Crosstalk-Aware Routing, Modulation, Core, and Spectrum Allocation for Sliceable Demands in SDM-EONs,” in 2024 IEEE 30th International Symposium on Local and Metropolitan Area Networks (LANMAN), 2024, pp. 76–81.
- [15] Y. Wang and V. M. Vokkarane, “Light-segment: Crosstalk-and Modulation-Aware Spectrum Allocation with Segmentation in SDM-EON,” in ICC 2020-2020 IEEE International Conference on Communications (ICC). IEEE, 2020, pp. 1–6.