Suitability of coord-sim for VNFs placement

[AlexPasqua]

I was exploring coord-sim for my MSc thesis and I've also read the paper of DeepCoord [2]. I have a couple of doubts...
(@federicaunipi correct me if I'm wrong)

---

Clarify some terminology differences

First I'd clarify some terminology differences between the paper whose results I'm trying to reproduce ([1]) and coord-sim / DeepCoord / [2] (just to be sure):

• for my scope, we can consider SFs (service functions) equivalent to VNFs (virtual network functions), and these terms can be used interchangeably
• SFCs to be placed can be considered equivalent to NSPRs (network slice placement requests)

---

What I'm trying to do

Then, what I'm trying to do is a little bit different compared to [2]:

• we have a series of NSPR (network slice placement request) [1] and we want to maximize the number of those that can be placed on the physical network
• evey request comprehends some VNFs and some virtual links (VLs) that have to be placed on the physical network, but VNFs are not shared among different requests (different SFCs cannot share the same SFs).
• we do not consider scheduling or coordination
  • therefore we do not have the concept of flows

In the end we only have some requests, comprehending some VNFs and VLs, to be placed on the physical network (maximixing the number of placed requests, load balancing and so on through a RL algorithm).

---

Doubts:

• You said here that coord-sim is built <<for training and running reinforcement learning approaches for network coordination/control, particularly VNF placement>>
  • At the same time the implementation of the simulator looks very flow-based (e.g. the Python class of the simulator is called FlowSimulator)

My main question is: is it possible to use coord-sim to perform only VNFs placement through a RL algorithm, without taking into consideration flows / scheduling / network coordination?

Thanks in advance! :)

---

References:

[1]. A Heuristically Assisted Deep Reinforcement Learning Approach for Network Slice Placement, Esteves et al., 2021
[2]. Self-Driving Network and Service Coordination Using Deep Reinforcement Learning, Schneider et al., 2020

[stefanbschneider]

Not sure about NSPRs, but otherwise I agree with the terminology. I also call VNFs/SFs components and SFCs/NSPRs services to be more general.
One current assumption/restriction of coord-sim is that SFCs/function chains are assumed to be linear, i.e., no branches or loops. Is that in line with what you need?

---

Your plan sounds good. Do you consider requests to arrive over time and also placement to happen over time? In this case, you could model the these requests as flows.

Or is it an offline problem, where all requests are known and available from the beginning and do not change over time + you just want a single solution to place these requests?
In that case, coord-sim is probably not ideal, but could in principle still be used, that's what we did with B-JointSP.

The main focus of coord-sim is on network coordination, which I consider as 4 aspects: 1) Service scaling, 2) service placement, 3) flow scheduling, 4) flow routing.
If your approach only provides a subset for these problems, you could define a heuristic/dummy to solve the other problems.
For example, DeepCoord does not control flow routing but resorts to pre-defined shortest paths between all nodes.

---

If you have a problem with 4 requests that arrive over time, you could model it as 4 flows in coord-sim. Each flow/request, requests a service. If you do not want sharing of components/VNFs, you can enforce that by using different VNF names in each service.

Not sure if this is helpful? :)

[AlexPasqua]

Not sure if this is helpful? :)

Thank you very much @stefanbschneider , it is very helpful indeed! :)
(and sorry for replying a bit late)

Do you consider requests to arrive over time and also placement to happen over time? In this case, you could model the these requests as flows.

So, I can assume that requests arrive over time, and the idea is to process them in batches: at every time interval we check what requests have arrived and we try to place all of them, then after another time interval we'll have another batch of requests to be placed and so on.

The main focus of coord-sim is on network coordination, which I consider as 4 aspects: 1) Service scaling, 2) service placement, 3) flow scheduling, 4) flow routing. If your approach only provides a subset for these problems, you could define a heuristic/dummy to solve the other problems. For example, DeepCoord does not control flow routing but resorts to pre-defined shortest paths between all nodes.

We only need to work on service placement AND flow routing.
We need to use coord-sim to simulate the arrival of the requests, call an external decision maker giving it the requests and the state of the physical network, and then implement the taken decisions in the simulator (i.e., actually place the VNFs on the physical nodes and the virtual links on the physical ones etc).

I need to identify the parts in the simulator which are responsible for those 4 tasks (service scaling, service placement, flow scheduling and flow routing). Are they modular and easily modifiable?

Thank you!

[stefanbschneider]

I can assume that requests arrive over time, and the idea is to process them in batches

That's a bit different than the assumptions we had in our work so far. So far, we considered the problem in two ways:
Either, we make decisions individually for each flow/request, whenever a flow arrives at the network.
Or, we build general rules about how to balance incoming requests between VNFs, eg, 50% go to instance 1 and 50% go to instance 2, i.e. independent of individual requests.

Still, I think processing requests in batches is something that can be implemented on top/in coord-sim. There are some fundamental concepts/assumptions in coord-sim that should be clear though:

• coord-sim uses discrete event simulation, i.e., in the simulation, events occur, e.g., when a flow arrives or is processed or when some predefined number of time steps elapsed. You can define at which of these events you want to gain back control, get an observation, and take the next action.
• Flows/requests in coord-sim arrive over time and have a pre-defined, fixed data rate and length. They traverse the network going from node to node. Based on the flow length, a single flow can occupy multiple links and be processed at multiple VNFs at the same time. Think of the old "snake" game where the snake moves around the 2D map.

So to implement request processing in batches, you'd have to define multiple "long"(?) flows at the same time with the same length. You need to get some observation of all individual flows in the batch that you want to give to your decision maker. You need to get an action for all these flows, deploy the decisions for how to route the flows and where to place the VNFs. Then have the simulation running until all flows have been processed and the next batch arrives.
For monitoring and evaluation, you can define separate intervals in which different network metrics are checked and collected.

Do you think that makes sense, i.e., are these fundamental concepts in line with what you need?

---

For implementing, we did try to make coord-sim as modular as possible but it is surely not perfect.

• The decision maker gives actions to the controller that interprets the actions and deploys them in the network, ie, places the VNFs and configures the routing rules. That's something you'd have to implement.
• There is a base controller that you can/should inherit from: https://github.com/RealVNF/coord-sim/blob/master/src/coordsim/controller/base_controller.py
• Inside the controller, you also define how long to run the simulation until the next observation is returned and the next aciton is expected. Currently, we have two options:
  • Per flow, ie, whenever a flow arrives at a node: https://github.com/RealVNF/coord-sim/blob/master/src/coordsim/controller/flow_controller.py
  • In fixed time intervals independent of flow arrival: https://github.com/RealVNF/coord-sim/blob/master/src/coordsim/controller/duration_controller.py
  • In both cases, check the self.env.run(), which defines how long to run utnil the next interaction. Eg, here: https://github.com/RealVNF/coord-sim/blob/master/src/coordsim/controller/flow_controller.py#L84
• Other than that, you'll need to define the observations/state to pass to the decision maker
• And to define metrics you want to collect.

Definenitely some work and I can't promise that everything works perfectly. But I'm happy to give advise as much as I can (with limited time and also based on what I remember when I last used coord-sim almost 2 years ago).

[AlexPasqua]

Hello @stefanbschneider ,
sorry for the late reply, but in the end we decided to go on implementing our own simulator.

This is mostly due to the fact that there are many small differences between coord-sim and what we need. It might work anyway (and I think it probably would), but it would be much more "painful" than simply implementing from scratch what we need exactly.

Thank you very much for your support anyway, it was very useful!