Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/realvnf/bjointsp-adapter

Adapter to map the inputs and outputs of the B-JointSP to the simulator interface
https://github.com/realvnf/bjointsp-adapter

adapter mano nfv python resource-allocation vnf vnf-placement

Last synced: about 2 months ago
JSON representation

Adapter to map the inputs and outputs of the B-JointSP to the simulator interface

Host: GitHub
URL: https://github.com/realvnf/bjointsp-adapter
Owner: RealVNF
Created: 2019-06-25T13:20:17.000Z (over 5 years ago)
Default Branch: master
Last Pushed: 2020-12-14T16:25:02.000Z (about 4 years ago)
Last Synced: 2023-03-06T04:17:50.942Z (almost 2 years ago)
Topics: adapter, mano, nfv, python, resource-allocation, vnf, vnf-placement
Language: Python
Size: 9.36 MB
Stars: 0
Watchers: 2
Forks: 3
Open Issues: 0
Metadata Files:
- Readme: README.md

Awesome Lists containing this project

README

[![Build Status](https://travis-ci.com/RealVNF/bjointsp-adapter.svg?branch=master)](https://travis-ci.com/RealVNF/bjointsp-adapter)

# BJointSP-adapter Advanced

Adapter to map the inputs and outputs of the B-JointSP to the simulator interface

B-JointSP should work with the [flow-level simulator](https://github.com/RealVNF/coordination-simulation), ie, be aligned to the [interface](https://github.com/RealVNF/coordination-simulation/blob/master/src/siminterface/interface/siminterface.py). This requires mapping the simulator state into something B-JointSP understands and mapping B-JointSP's outputs/placement into something the simulator understands.

## Working Details

BjoinSP-adapter does the conversion in the following order:

1. Calls BjoinSP's `place` function with the following parameters:
1. `network file`: path to the file
2. `template`:path to the file created (just created once and used for every subsequent call to `place`) with the following assumptions/adjustments:
3. Each VNF has no memory (for simplicity)
4. An artificial VNF `vnf_source` having no `vnf_delay` is added and connected to the first VNF of the SFC
5. For each VNF, `vnf_delay` = `processing_delay_mean` from the `config` file
6. VNFs only have a forward link
7. The vnf_links has a very high `max_delay` = 1000
8. `source` : path to a first source file. Since we at the beginning don't have any traffic information from the simulator we have to create this file statically. Each ingress node in the network is assumed to be a source having a single VNF `vnf_source` and the number of flows is calculated by calculating the number of `overlapping` flows as follows:
overlapping_flows = math.ceil((num_flows \* (processing_delay + flow_duration))/run_duration)
- number of flows: is given by the simulator in the `traffic_info`
- processing_delay: taken from the service_function file
- flow_duration: (flow_size / flow_dr_mean) \* 1000
- run_duration: taken from the config file
9. `cpu` = `mem` = `node_capacity` from the network file
10. It gets the NetworkX object from the simulator, including the node and link capacities.
2. The results of the `place` call from step `1.` above are used to create the placement and schedule for the simulator as follows:
1. `placement`: The placements are simply obtained from the result of `place` call.
2. `schedule`: Since BJointSP does not return any schedule we have create it from the flows information returned by `place`. We assume that there is only a single SFC for simplicity. `flows` keeps track of the number of flows forwarded by BJointSP from a source_node to a dest_node. The schedule is created for each `source node`, for each `VNF` in the SFC, for each `destination node`. If a flow exits in `flows` from source node to destination node for a requested VNF we add it to the schedule. We use the probabilities normalization function `normalize_scheduling_probabilities` such that for each SF the sum of Probabilities is 1
3. The `schedule` and `placement` from step `2.` are used to call the `apply` function of the simulator.
4. The result (traffic info.) of the `apply` call from step `3.` are used to create the `sources` for the next call to BjoinSP's `place` function. The sources are created as follows:

1. For each ingress node, if the first SF (in our cases `a`) has some aggregate dr , we calculate the number of overlapping flows as follows:

`overlapping_flows = math.ceil((num_flows * (processing_delay + flow_duration))/run_duration)`

We then place `overlapping_flows` number of flows, each of `dr` = `flow_dr_mean` on that ingress node with a single VNF `vnf_source`

2. If traffic_info has no `dr` for `a` on any ingress node, then the source file would be empty

5. If the `source` is created in step `4.` we use it to call BJointSP's `place` and repeat step 2, 3, & 4.
6. If the `source` is not created in step `4.`, the previously calculated `schedule` and `placement` is used to make the next call to the simulator's `apply`.

#### Note: By calculating the overlapping_flows we can run the adapter with any `run_duration`. B-JointSP expects flows that are specified as sources to run in parallel and be competing for resources. A flow is competing for resources while it's being processed by a VNF. So by calculating the number of overlapping_flows we know how many parallel flows that BJointSP needs to cater to.

## Setup

Install [Python 3.6](https://www.python.org/downloads/release/) and [venv](https://docs.python.org/3/library/venv.html) modules.

_Recommended for development_: Clone and install [coord-sim](https://github.com/RealVNF/coord-sim), [common-utils](https://github.com/RealVNF/common-utils), and [BJointSP](https://github.com/CN-UPB/B-JointSP) locally first in the same venv before running the installation of the adapter in the `editable` mode: `pip install -e bjointsp-adapter`

```bash
# clone this repo and enter dir
git clone [email protected]:RealVNF/bjointsp-adapter.git
cd bjointsp-adapter

# create and activate virtual environment
## On Windows
python -m venv venv
.\venv\Scripts\activate

## On Linux and macOS
python3 -m venv venv
source venv/bin/activate

# install package
pip install -r requirements.txt
```
This also installs the required [coord-sim](https://github.com/RealVNF/coord-sim) simulator, [common-utils](https://github.com/RealVNF/common-utils), and [BJointSP](https://github.com/CN-UPB/B-JointSP) package.

## Usage

```
usage: bjointsp-adapter [-h] [-i ITERATIONS] [-s SEED] -n NETWORK -sf
SERVICE_FUNCTIONS -c CONFIG

BJointSP Adapter

optional arguments:
-h, --help show this help message and exit
-i ITERATIONS, --iterations ITERATIONS
-s SEED, --seed SEED
-n NETWORK, --network NETWORK
-sf SERVICE_FUNCTIONS, --service_functions SERVICE_FUNCTIONS
-c CONFIG, --config CONFIG
```

Use the following command as an example (from within bjointsp-adapter project folder):

```bash
bjointsp-adapter -n "res/networks/triangle.graphml" \
-sf "res/service_functions/abc.yaml" \
-c "res/config/sim_config.yaml" \
-i 50
```

This will run the bjointsp-adapter and call the `apply()` of the sim-interface and the `place()` of BJointSP 50 times.

### Using the parallel script to run multiple experiments:

There is script provided in the `scripts` folder that utilizes the [GNU Parallel](https://www.gnu.org/software/parallel/) utility to run multiple experiments at the same time to speed up the process. It can run one algorithm at a time, so you need to choose the algo you wanna run at the beginning of the file.

From [scripts directory](scripts) configure the following files:

- [network_files](scripts/network_files.txt): 1 network file location per line
- [config_files](scripts/config_files.txt): 1 simulator config. file location per line
- [service_files](scripts/service_files.txt): 1 SFC file location per line
- [30seeds](scripts/30seeds.txt): 1 seed per run of the simulator. By default using 30 seeds. Add/Remove as per requirement

From the main directory (where the README.md file is) using a Terminal run:

```bash
bash scripts/run_parallel
```

## Acknowledgement

This project has received funding from German Federal Ministry of Education and Research ([BMBF](https://www.bmbf.de/)) through Software Campus grant 01IS17046 ([RealVNF](https://realvnf.github.io/)).