def makeState(self):
#Version 1
if self.stateVersion == 1:
bwUsed = Util.bandwithUsed(self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc)
return [self.nbSlicesAddSinceLastReconf, self.nbSlicesRejectSinceLastReconf, self.nbSlicesRemoveSinceLastReconf, self.nbMinutesSinceLastReconf, float(bwUsed)/self.topology.linksCapacity, float(self.timeStep)/len(self.scenario.listOfArrival)]
#Version 2
elif self.stateVersion == 2:
print("Version make state NOOOO")
exit()
bwUsed, nbVnfUsed = Util.bandwithAndVnfUsed(self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc)
maxBwServed = self.topology.numberLinksToBaseStations * self.topology.capacityEdgeLinks
bwServed = 0
for s in self.allocateur.listSlicesCurrentlyAllocated:
bwServed += s.bd
return [ float(bwServed)/maxBwServed, float(nbVnfUsed)/self.nbVnf, float(bwUsed)/self.topology.linksCapacity, float(self.timeStep)/len(self.scenario.listOfArrival)]
#Version 3
elif self.stateVersion == 3:
return [float(self.nbMinutesSinceLastReconf)/len(self.scenario.listOfArrival), float(self.timeStep)/len(self.scenario.listOfArrival)]
#Version 4
elif self.stateVersion == 4:
return [float(self.nbSlicesAddSinceLastReconf)/len(self.scenario.listOfArrival), float(self.nbSlicesRemoveSinceLastReconf)/len(self.scenario.listOfArrival), float(self.nbMinutesSinceLastReconf)/len(self.scenario.listOfArrival), float(self.timeStep)/len(self.scenario.listOfArrival)]
#Version 5
elif self.stateVersion == 5:
linksUsage, nodesUsage, nodeFunction = Util.utilisationAndVnfUsed(self.functions, self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc, roundNumber = 8)
newCostVnfsUsed = 0
for u in nodesUsage:
for f in nodeFunction[u]:
newCostVnfsUsed += self.functions[f][1]
return [float(self.nbSlicesAddSinceLastReconf)/len(self.scenario.listOfArrival), float(self.nbSlicesRemoveSinceLastReconf)/len(self.scenario.listOfArrival), float(self.nbMinutesSinceLastReconf)/len(self.scenario.listOfArrival), float(self.timeStep)/len(self.scenario.listOfArrival), newCostVnfsUsed]
#Version 6
elif self.stateVersion == 6:
return [float(self.nbSlicesAddSinceLastReconf)/len(self.scenario.listOfArrival), float(self.nbSlicesRemoveSinceLastReconf)/len(self.scenario.listOfArrival), float(self.nbMinutesSinceLastReconf)/len(self.scenario.listOfArrival)]
def _step(self, action):
if self._episode_ended:
return self._reset()
self.reconfsDone.append(action.item(0))
""" ################################################################################################################# """
""" We first reconfigure to see if we have an improvement """
""" ################################################################################################################# """
#print("Debug Env : Step {}".format(self.timeStep))
listListSlicesState = []
listListSlicesFakeAlloc = []
listListSlicesCost = []
for _ in range(self.numberOfStepsByState):
listSlices = self.scenario.getNewSlices()
if listSlices == None:
listListSlicesState.append(None)
listListSlicesFakeAlloc.append(None)
break
else:
listListSlicesState.append(listSlices)
listListSlicesFakeAlloc.append(listSlices)
iteratorTmp = self.scenario.iteratorArrival
for _ in range(self.numberOfStepsByState, self.numberOfStepsForCost):
if iteratorTmp == self.scenario.nbTimeStep:
listListSlicesCost.append(None)
listListSlicesFakeAlloc.append(None)
break
else:
listListSlicesCost.append(self.scenario.listOfArrival[iteratorTmp])
listListSlicesFakeAlloc.append(self.scenario.listOfArrival[iteratorTmp])
iteratorTmp+=1
"""
if self.timeStep % 150 == 0:
print("EnvironementCost %")
#if self.timeStep == param.startDynamic:
action = 1
else:
action = 0"""
"""if self.timeStep == 205:
exit()"""
listProfit = []
listCostVnfUsed = []
listProfitNoReconf = []
listCostVnfNoReconf = []
if self.rewardVersion == 4:
listCostVnfNoReconf, listBwAllocatedNoReconf, listProfitNoReconf = self.realAlloc(self.allocateurNoReconf, listListSlicesState)
#I the action is to reconfigure
if action == 1:
if self.rewardVersion == 4:
listCostVnfNoReconfTmp, listBwAllocatedNoReconfTmp, listProfitNoReconfTmp = self.fakeAlloc(self.allocateurNoReconf, listListSlicesCost)
for i in range(len(listProfitNoReconfTmp)):
listProfitNoReconf.append(listProfitNoReconfTmp[i])
#listBwAllocatedNoReconf.append(listBwAllocatedNoReconfTmp[i])
listCostVnfNoReconf.append(listCostVnfNoReconfTmp[i])
else:
listCostVnfNoReconf, listBwAllocatedNoReconf, listProfitNoReconf = self.fakeAlloc(self.allocateur, listListSlicesFakeAlloc)
if self.evaluation:
self.listTimeStepReconf.append(self.timeStep)
periodeList = param.timePeriodeDynamic
periode = "D3"
for i in periodeList:
if self.timeStep >= i:
periode = periodeList[i]
self.listPeriodeReconf.append(periode)
self.listNbSlicesAddSinceLastReconf.append(self.nbSlicesAddSinceLastReconf)
self.listNbSlicesRemoveSinceLastReconf.append(self.nbSlicesRemoveSinceLastReconf)
self.listNbMinutesSinceLastReconf.append(self.nbMinutesSinceLastReconf)
bwUsed, nbVnfUsed = Util.bandwithAndVnfUsed(self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc)
self.listPercBandwidthUsed.append(float(bwUsed)/self.topology.linksCapacity*100)
self.listPercVnfUsed.append(float(nbVnfUsed)/self.nbVnf*100)
maxBwServed = 0
if len(self.topology.listBaseStation) > 0:
for (u,v) in self.topology.links:
if u in self.topology.listBaseStation:
maxBwServed += self.topology.links[0]
else :
maxBwServed = 1
bwAllocated = 0
for s in self.allocateur.listSlicesCurrentlyAllocated:
bwAllocated += s.bd
self.listPercBandwidthAllocated.append(float(bwAllocated)/maxBwServed*100)
self.listNbSlicesAllocated.append(len(self.allocateur.listSlicesCurrentlyAllocated))
bwAllocated = 0
for s in self.allocateur.listSlicesCurrentlyAllocated:
bwAllocated += s.bd
linksUsage, nodesUsage, nodeFunction = Util.utilisationAndVnfUsed(self.functions, self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc, roundNumber = 8)
CostVnfsUsed = 0
for u in nodesUsage:
for f in nodeFunction[u]:
CostVnfsUsed += self.functions[f][1]
costByMb = CostVnfsUsed/float(bwAllocated)
self.doIReconfigureNow = True
self.allocateur.update(self.timeStep, remove = False)
self.doIReconfigureNow = False
listProfit.append(self.allocateur.profit[int(self.timeStep - param.startDynamic)])
listCostVnfUsed.append(self.allocateur.CostVnfsUsed[int(self.timeStep - param.startDynamic)])
if self.evaluation:
newBwAllocated = 0
for s in self.allocateur.listSlicesCurrentlyAllocated:
newBwAllocated += s.bd
linksUsage, nodesUsage, nodeFunction = Util.utilisationAndVnfUsed(self.functions, self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc, roundNumber = 8)
newCostVnfsUsed = 0
for u in nodesUsage:
for f in nodeFunction[u]:
newCostVnfsUsed += self.functions[f][1]
newCostByMb = newCostVnfsUsed/float(newBwAllocated)
self.listImprovVnf.append((CostVnfsUsed - newCostVnfsUsed)/float(CostVnfsUsed)*100)
self.listImprovCostMb.append((costByMb - newCostByMb)/float(costByMb)*100)
else:
self.allocateur.update(self.timeStep, remove = False)
listProfit.append(self.allocateur.profit[int(self.timeStep - param.startDynamic)])
listCostVnfUsed.append(self.allocateur.CostVnfsUsed[int(self.timeStep - param.startDynamic)])
#print("{} {} {}".format(self.timeStep, self._state, action))
""" ################################################################################################################# """
""" We add the new slices before the new reconfiguration """
""" ################################################################################################################# """
for i in range(self.numberOfStepsByState):
self.timeStep += 1
listSlices = listListSlicesState[i]
if listSlices == None:
if action == 1:
bwAllocated = 0
for s in self.allocateur.listSlicesCurrentlyAllocated:
bwAllocated += s.bd
linksUsage, nodesUsage, nodeFunction = Util.utilisationAndVnfUsed(self.functions, self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc, roundNumber = 8)
CostVnfsUsed = 0
for u in nodesUsage:
for f in nodeFunction[u]:
CostVnfsUsed += self.functions[f][1]
reward = self.makeReward(listProfit, listProfitNoReconf, listCostVnfUsed, listCostVnfNoReconf, action)
if self.evaluation and action == 1:
bwAllocated = 0
for s in self.allocateur.listSlicesCurrentlyAllocated:
bwAllocated += s.bd
linksUsage, nodesUsage, nodeFunction = Util.utilisationAndVnfUsed(self.functions, self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc, roundNumber = 8)
CostVnfsUsed = 0
for u in nodesUsage:
for f in nodeFunction[u]:
CostVnfsUsed += self.functions[f][1]
#fakeCostByMb = fakeCostVnfsUsed/float(fakeBwAllocated)
costByMb = CostVnfsUsed/float(bwAllocated)
self.listReward.append(reward)
#self.listImprovVnfVsFake.append((fakeCostVnfsUsed - CostVnfsUsed)/float(fakeCostVnfsUsed)*100)
#self.listImprovCostMbVsFake.append((fakeCostByMb - costByMb)/float(fakeCostByMb)*100)
self.rewardTotal += reward
self._episode_ended = True
self.listInstanceAlreadyTrained.append(self.listInstanceFiles[0])
#self.saveTest()
if self.evaluation:
self.saveEvaluation()
del(self.listInstanceFiles[0])
print("Number reconf done {}".format(sum(self.reconfsDone)))
print("Reward : {}".format(self.rewardTotal))
"""print("")
print(" {} {} {} {}".format(action, realFirstCost, costByMb, reward))"""
self._state = self.makeState()
return ts.termination(np.array([self._state], dtype=np.float32), reward=reward)
else:
for s in listSlices:
self.allocateur.addSlice(s, self.timeStep)
if self.allocateur.listSlicesAccepted[-1].id == s.id:
self.nbSlicesAddSinceLastReconf+=1
else:
self.nbSlicesRejectSinceLastReconf
self.nbMinutesSinceLastReconf +=1
nbSlices = len(self.allocateur.listSlicesCurrentlyAllocated)
#We do not do the update for the last, it will be done at the next step
if i < self.numberOfStepsByState-1:
self.allocateur.update(self.timeStep)
listProfit.append(self.allocateur.profit[int(self.timeStep - param.startDynamic)])
listCostVnfUsed.append(self.allocateur.CostVnfsUsed[int(self.timeStep - param.startDynamic)])
#listProfitNoReconf.append(self.listProfitNoReconf[self.timeStep - param.startDynamic])
else:
self.allocateur.removeSlices(self.timeStep)
self.nbSlicesRemoveSinceLastReconf += nbSlices-len(self.allocateur.listSlicesCurrentlyAllocated)
listCostVnfAdditionnal, listBwAllocatedAdditionnal, listProfitAdditionnal = listCostVnfUsed, [], listProfit
if action == 1:
bwAllocated = 0
for s in self.allocateur.listSlicesCurrentlyAllocated:
bwAllocated += s.bd
linksUsage, nodesUsage, nodeFunction = Util.utilisationAndVnfUsed(self.functions, self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc, roundNumber = 8)
CostVnfsUsed = 0
for u in nodesUsage:
for f in nodeFunction[u]:
CostVnfsUsed += self.functions[f][1]
#We complete by a knew fake alloc to compare with more step (numberOfStepsForCost) than just numberOfStepsByState
listCostVnfAdditionnal, listBwAllocatedAdditionnal, listProfitAdditionnal = self.fakeAlloc(self.allocateur, listListSlicesCost)
for i in range(len(listProfit)):
listProfitAdditionnal.append(listProfit[i])
#listBwAllocatedAdditionnal.append(aaaaa[i])
listCostVnfAdditionnal.append(listCostVnfUsed[i])
reward = self.makeReward(listProfitAdditionnal, listProfitNoReconf, listCostVnfAdditionnal, listCostVnfNoReconf, action)
if self.evaluation and action == 1:
bwAllocated = 0
for s in self.allocateur.listSlicesCurrentlyAllocated:
bwAllocated += s.bd
linksUsage, nodesUsage, nodeFunction = Util.utilisationAndVnfUsed(self.functions, self.allocateur.listSlicesCurrentlyAllocated, self.allocateur.currentAlloc, roundNumber = 8)
CostVnfsUsed = 0
for u in nodesUsage:
for f in nodeFunction[u]:
CostVnfsUsed += self.functions[f][1]
#fakeCostByMb = fakeCostVnfsUsed/float(fakeBwAllocated)
costByMb = CostVnfsUsed/float(bwAllocated)
self.listReward.append(reward)
#self.listImprovVnfVsFake.append((fakeCostVnfsUsed - CostVnfsUsed)/float(fakeCostVnfsUsed)*100)
#self.listImprovCostMbVsFake.append((fakeCostByMb - costByMb)/float(fakeCostByMb)*100)
self.rewardTotal += reward
"""print("")
print(" {} {} {} {}".format(action, realFirstCost, costByMb, reward))"""
self._state = self.makeState()
#print("{} {}".format(reward, self._state))
return ts.transition(np.array([self._state], dtype=np.float32), reward=reward, discount=self.gammaDiscount)
