def migrationOneOrMore(self, unreliableSFCList,
unreliableSFCReliabilityList):
self.neededMigrationSFCList = []
self.totalReliabilityBelowDegree = 0
self.reliabilityBelowDegreeList = []
for i in range(len(unreliableSFCList)):
print("unreliableSFCList[i] = %d" % unreliableSFCList[i])
SFCInstance = SFC(
unreliableSFCList[i],
sfcListSingleton.dict_maxDelay[unreliableSFCList[i]],
sfcListSingleton.dict_minReliability[unreliableSFCList[i]],
sfcListSingleton.dict_VNFList[unreliableSFCList[i]],
sfcListSingleton.dict_createdtime[unreliableSFCList[i]])
requiredReliability = SFCInstance.getRequestMinReliability()
reliabilityBelowDegree = (
requiredReliability -
unreliableSFCReliabilityList[i]) / requiredReliability
self.totalReliabilityBelowDegree += reliabilityBelowDegree
self.neededMigrationSFCList.append(unreliableSFCList[i])
self.reliabilityBelowDegreeList.append(reliabilityBelowDegree)
if (self.totalReliabilityBelowDegree >= THRESHOLD_DEGREE):
return True
else:
return False
def getQoSDecreationOfSFC(self, migrated_SFC_id, needMigratedVNFList,
destinationPhysicalNodeList):
# beta1与beta2分别表示Si重要性与SFC暂停时间对服务质量的影响程度
beta1 = 0.5
beta2 = 0.5
servicePauseTime = self.getMigrationTime(migrated_SFC_id,
needMigratedVNFList,
destinationPhysicalNodeList)
allSFCsImportance = 0
for sfcInstanceId in sfcListSingleton.getSFCList():
sfcInstance = SFC(
sfcInstanceId, sfcListSingleton.dict_maxDelay[sfcInstanceId],
sfcListSingleton.dict_minReliability[sfcInstanceId],
sfcListSingleton.dict_VNFList[sfcInstanceId],
sfcListSingleton.dict_createdtime[sfcInstanceId])
allSFCsImportance += sfcInstance.importance
QoSDecreationOfSFC = beta1 * (SFC(
migrated_SFC_id,
sfcListSingleton.dict_maxDelay[migrated_SFC_id],
sfcListSingleton.dict_minReliability[migrated_SFC_id],
sfcListSingleton.dict_VNFList[migrated_SFC_id],
sfcListSingleton.dict_createdtime[migrated_SFC_id],
).importance / allSFCsImportance)
+beta2 * (servicePauseTime / (time.time() - SFC(
migrated_SFC_id, sfcListSingleton.dict_maxDelay[migrated_SFC_id],
sfcListSingleton.dict_minReliability[migrated_SFC_id],
sfcListSingleton.dict_VNFList[migrated_SFC_id],
sfcListSingleton.dict_createdtime[migrated_SFC_id]).create_time))
return QoSDecreationOfSFC
def getResourceIncreationOfSFC(self, migrated_SFC_id,
SFCRequestedResourceBefore):
sfcInstance = SFC(
migrated_SFC_id, sfcListSingleton.dict_maxDelay[migrated_SFC_id],
sfcListSingleton.dict_minReliability[migrated_SFC_id],
sfcListSingleton.dict_VNFList[migrated_SFC_id],
sfcListSingleton.dict_createdtime[migrated_SFC_id])
SFCRequestedResourceAfter = sfcInstance.getSFCRequestedResource()
return SFCRequestedResourceAfter - SFCRequestedResourceBefore
def getDelayIncreationOfSFC1(self, migrated_SFC_id, nodebeforelist,
nodeafterlist):
delayadd = 0
for i in range(len(nodebeforelist)):
nodebefore = nodebeforelist[i]
nodeafter = nodeafterlist[i]
SFCInstance = SFC(
migrated_SFC_id,
sfcListSingleton.dict_maxDelay[migrated_SFC_id],
sfcListSingleton.dict_minReliability[migrated_SFC_id],
sfcListSingleton.dict_VNFList[migrated_SFC_id],
sfcListSingleton.dict_createdtime[migrated_SFC_id])
delayadd += SFCInstance.getDelayBetweenPhysicalNode(
nodebefore, nodeafter)
print("delayadd = %f" % delayadd)
def evaluation(self):
totalRelibility = 0
for SFCId in sfcListSingleton.getSFCList():
SFCInstance = SFC(SFCId, sfcListSingleton.dict_maxDelay[SFCId],
sfcListSingleton.dict_minReliability[SFCId],
sfcListSingleton.dict_VNFList[SFCId],
sfcListSingleton.dict_createdtime[SFCId])
totalRelibility += SFCInstance.get_SFC_relialibility(
SFCInstance.getVNFList())
print("totalRelibility = %f" % totalRelibility)
costInstance = MigrationCostCaculation()
cost = costInstance.getCostOfMigratingVNFsOnOneSFC(
self.migrated_SFC_id, self.SFCDelayBeforMigration,
self.SFCRequestedResourceBefore, self.needMigratedVNFList,
self.destinationPhysicalNodeList)
print("cost = %f" % cost)
return 100 + totalRelibility - cost
def getMigrationTime(self, migrated_SFC_id, needMigratedVNFList,
destinationPhysicalNodeList):
# 存放此SFC上需要迁移的VNF们的迁移所需要的时间
VNFsMigrationTimeList = []
# 由SFC的ID得到此条SFC上所有的VNF
SFCInstance = SFC(
migrated_SFC_id, sfcListSingleton.dict_maxDelay[migrated_SFC_id],
sfcListSingleton.dict_minReliability[migrated_SFC_id],
sfcListSingleton.dict_VNFList[migrated_SFC_id],
sfcListSingleton.dict_createdtime[migrated_SFC_id])
VNFList = SFCInstance.getVNFList
total_time = 0
# 寻找此SFC上应当进行迁移的VNF(s),根据不同的迁移情形分别获取，在本项目中的其他位置实现此方法
# 假设此时在此处已经获取到了需要迁移的VNF，即为needMigratedVNFList,此列表作为输入参数由外部传入
# 系统开始运行之前随机给每个VNF赋一个迁移时间的系数，当迁移发生时，此系数乘以源至目的地的距离，作为相对迁移时间。
# 也就是说还需要一个迁移目的地列表，此处同样作为输入参数传入,源到目的地之间的距离直接用拓扑中的时延来代替
for i in range(len(needMigratedVNFList)):
vnfid = needMigratedVNFList[i]
VNFInstance = VNF(vnfid, vnfListSingelton.dict_VNFListType[vnfid],
vnfListSingelton.dict_VNFRequestCPU[vnfid],
vnfListSingelton.dict_VNFRequestMemory[vnfid],
vnfListSingelton.dict_locatedVMID[vnfid],
vnfListSingelton.dict_locatedSFCIDList[vnfid],
vnfListSingelton.dict_numbersOnSFCList[vnfid],
vnfListSingelton.dict_VNFReliability[vnfid])
VMId = VNFInstance.get_VM_id(needMigratedVNFList[i])
VMInstance = VM(VMId, vmListSingelton.dict_VMRequestCPU[VMId],
vmListSingelton.dict_VMRequestMemory[VMId],
vmListSingelton.dict_VMLocatedPhysicalnode[VMId],
vmListSingelton.dict_VMReliability[VMId])
physicalNodeId = VMInstance.get_physicalNode_id(VMId)
# physicalNodeId与destinationPhysicalNodeList[i]两个物理节点之间的时延
delayBetweenSandDNodes = SFCInstance.getDelayBetweenPhysicalNode(
physicalNodeId, destinationPhysicalNodeList[i])
# 计算出此VNF迁移所花费的时间，并将其存放进VNFsMigrationTimeList中的第i个位置
VNFsMigrationTimeList.append(
delayBetweenSandDNodes *
VNFInstance.migration_time_coefficient)
total_time += delayBetweenSandDNodes * VNFInstance.migration_time_coefficient
return total_time
def SFC_reliability_caculating(self):
# 存储全网中SFC的可靠性
SFCReliabilityList = []
# 获取到网络中所有的SFC的列表
ALLSFCList = sfcListSingleton.getSFCList()
SFCReliabilityDict = {}
for i in range(len(ALLSFCList)):
print("SFC的ID为： %d" % ALLSFCList[i])
SFCInstance = SFC(
ALLSFCList[i], sfcListSingleton.dict_maxDelay[ALLSFCList[i]],
sfcListSingleton.dict_minReliability[ALLSFCList[i]],
sfcListSingleton.dict_VNFList[ALLSFCList[i]],
sfcListSingleton.dict_createdtime[ALLSFCList[i]])
SFCreliability = SFCInstance.getSFCReliabilityAtFirst()
# 字典,存放每个SFC的ID和可靠性
SFCReliabilityDict[ALLSFCList[i]] = SFCreliability
# SFCReliabilityDict['SFCID'] = ALLSFCList[i]
# SFCReliabilityDict['reliability'] = SFCreliability
# 列表里放的是所有的字典（不知道编译会不会通过）
# SFCReliabilityList.append(SFCReliabilityDict)
print(SFCReliabilityDict)
return SFCReliabilityDict
def getDelayIncreationOfSFC(self, migrated_SFC_id, SFCDelayBeforMigration):
SFCInstance = SFC(
migrated_SFC_id, sfcListSingleton.dict_maxDelay[migrated_SFC_id],
sfcListSingleton.dict_minReliability[migrated_SFC_id],
sfcListSingleton.dict_VNFList[migrated_SFC_id],
sfcListSingleton.dict_createdtime[migrated_SFC_id])
VNFList = SFCInstance.getVNFList()
print(VNFList)
nodeidlist = []
i = 0
for vnfid in VNFList:
if vnfid == 15:
VNFinstance = VNF(
vnfid, vnfListSingelton.dict_VNFListType[vnfid],
vnfListSingelton.dict_VNFRequestCPU[vnfid],
vnfListSingelton.dict_VNFRequestMemory[vnfid],
vnfListSingelton.dict_locatedVMID[vnfid],
vnfListSingelton.dict_locatedSFCIDList[vnfid],
vnfListSingelton.dict_numbersOnSFCList[vnfid],
vnfListSingelton.dict_VNFReliability[vnfid])
vmid = VNFinstance.get_VM_id(vnfid)
VMinstance = VM(
vmid, vmListSingelton.dict_VMRequestCPU[vmid],
vmListSingelton.dict_VMRequestMemory[vmid],
vmListSingelton.dict_VMLocatedPhysicalnode[vmid],
vmListSingelton.dict_VMReliability[vmid])
nodeid = VMinstance.get_physicalNode_id(vmid)
print("before node id = %d" % nodeid)
VMinstance.setPhysicalNodeId(16)
SFCDelayAfterMigration = SFCInstance.get_SFC_delay(VNFList)
print("SFCDelayAfterMigration = %f" % SFCDelayAfterMigration)
print("SFCDelayBeforMigration = %f" % SFCDelayBeforMigration)
print(SFCDelayAfterMigration - SFCDelayBeforMigration)
return SFCDelayAfterMigration - SFCDelayBeforMigration
def find_a_SFC(self, MaxSFCDelay, MinSFCReliablity, VNFTyprList,
VNFRequestCPU, VNFRequestMemory):
print("发现一条SFC方法")
# 存储根据VNF类型和所需CPU、内存资源条件筛选出来的VNFs
VNFList = []
for i in range(len(VNFTyprList)):
aVNFInstance = VNF()
vmInstance = VM()
physicalInstace = PhysicalNode()
vmId = aVNFInstance.get_VM_id(self.getAVNFByType())
physicalNodeId = vmInstance.get_physicalNode_id(vmId)
if (physicalInstace.getAvailable_CPU(physicalNodeId) >
VNFRequestCPU
and physicalInstace.getAvailable_Memory(physicalNodeId) >
VNFRequestMemory):
# 将此VNF的id加入到list中，作为此SFC中的一环
VNFList.append(self.getAVNFByType())
# 所有需要的VNF都找到了，一条SFC就挑选出来了
sfcid = sfcListSingleton.getSFCCount() + 1
sfcInstance = SFC(sfcid, MaxSFCDelay, MinSFCReliablity, VNFList,
datetime.datetime.now())
# 接下来判断此SFC是否满足时延和可靠性的约束
if (sfcInstance.get_SFC_delay(VNFList) < MaxSFCDelay):
if (sfcInstance.get_SFC_relialibility(VNFList) > MinSFCReliablity
and sfcInstance.SFC_id
not in sfcListSingleton.SFCList): # 此SFC没有被选择过
sfcInstance.setDelay(sfcInstance.get_SFC_delay(VNFList))
# SFC满足要求,返回值是SFC实例
sfcListSingleton.addSFCCount()
sfcInstance.SFC_id = sfcListSingleton.getSFCCount() + 1
sfcListSingleton.addSFC(sfcListSingleton.getSFCCount() + 1)
return sfcInstance
else:
print("此SFC实例的可靠性不满足要求")
else:
print("此SFC实例的时延不满足要求")
def find_a_SFC1(self, MaxSFCDelay, MinSFCReliablity, VNFTyprList,
VNFRequestCPU, VNFRequestMemory):
print("发现一条SFC方法开始")
# 存储根据VNF类型和所需CPU、内存资源条件筛选出来的VNFs
VNFList = []
for i in range(len(VNFTyprList)):
vnftype = VNFTyprList[i]
vnfid = self.getAVNFByType(vnftype)
if vnfid != None:
aVNFInstance = VNF(
vnfid, vnfListSingelton.dict_VNFListType[vnfid],
vnfListSingelton.dict_VNFRequestCPU[vnfid],
vnfListSingelton.dict_VNFRequestMemory[vnfid],
vnfListSingelton.dict_locatedVMID[vnfid],
vnfListSingelton.dict_locatedSFCIDList[vnfid],
vnfListSingelton.dict_numbersOnSFCList[vnfid],
vnfListSingelton.dict_VNFReliability[vnfid])
vmid = aVNFInstance.get_VM_id(vnfid)
vmInstance = VM(
vmid, vmListSingelton.dict_VMRequestCPU[vmid],
vmListSingelton.dict_VMRequestMemory[vmid],
vmListSingelton.dict_VMLocatedPhysicalnode[vmid],
vmListSingelton.dict_VMReliability[vmid])
nodeid = vmInstance.get_physicalNode_id(vmid)
physicalInstace = PhysicalNode(
nodeid, nodeListSingelton.dict_capacity_CPU[nodeid],
nodeListSingelton.dict_capacity_Memory[nodeid],
nodeListSingelton.dict_provided_reliablity[nodeid])
if (physicalInstace.getAvailable_CPU(nodeid) > VNFRequestCPU[i]
and physicalInstace.getAvailable_Memory(nodeid) >
VNFRequestMemory[i]):
# 将此VNF的id加入到list中，作为此SFC中的一环
VNFList.append(vnfid)
else:
print("VNFid = none")
# 所有需要的VNF都找到了，一条SFC就挑选出来了
sfcid = self.SFCCount + 1
sfcInstance = SFC(sfcid, MaxSFCDelay, MinSFCReliablity, VNFList,
datetime.datetime.now())
# 接下来判断此SFC是否满足时延和可靠性的约束
print("SFC的时延与可靠性分别为：")
delay = sfcInstance.get_SFC_delay(VNFList)
print("SFC的时延为：%f" % delay)
reli = sfcInstance.get_SFC_relialibility(VNFList)
print("SFC的可靠性为：%f" % reli)
if (sfcInstance.get_SFC_delay(VNFList) < MaxSFCDelay):
if (sfcInstance.get_SFC_relialibility(VNFList) > MinSFCReliablity):
# and sfcInstance.SFC_id not in sfcListSingleton.getSFCList()): # 此SFC没有被选择过
sfcInstance.setDelay(sfcInstance.get_SFC_delay(VNFList))
# SFC满足要求,返回值是SFC实例
sfcListSingleton.addSFCCount()
sfcInstance.SFC_id = sfcListSingleton.getSFCCount() + 1
sfcListSingleton.addSFC(sfcListSingleton.getSFCCount() + 1)
print("SFC基本数据：-------------------------------------")
print("基本数据--SFC的ID为： %d" % sfcInstance.getSFCId())
print("基本数据--SFC中的vnflist为：")
print(VNFList)
print("基本数据--SFC的时延为： %f" % delay)
print("基本数据--SFC的可靠性为： %f " % reli)
with open('D:/pycharm workspace/GraduationProject/res/res.csv',
'a+',
newline='') as csvfile:
writer = csv.writer(csvfile)
# 先写入columns_name
writer.writerow(["VNFlist", "delay", "reliability"])
data = [[[VNFList], delay, reli]]
print(data)
# 写入多行用writerows
writer.writerows(data)
print("发现一条SFC方法结束")
return sfcInstance
else:
print("此SFC实例的可靠性不满足要求")
else:
print("此SFC实例的时延不满足要求")
def reliability_monitor(self):
print("可靠性监测方法主体")
# 如何能间隔不同的时间间隔调用相同的方法？
# 隔上一个时间间隔就要重新调用SFC_reliability_caculating()方法，计算网络中的SFC可靠性如何实现呢？
# 定义一个时间间隔变量，用于存储每次算出的时间间隔
timeIntervalVariable = self.reliability_monitor_timeInterval()
print("timeIntervalVariable = %d" % timeIntervalVariable)
# 睡眠时间
sleepTime = timeIntervalVariable
print("sleeptime = %d" % sleepTime)
self.cunrrentSFCReliabilityList = self.SFC_reliability_caculating()
while (True):
# # 睡眠时间
# sleepTime = timeIntervalVariable
# print("sleeptime = %d" % sleepTime)
# # 每次都要更新
# timeIntervalVariable = self.reliability_monitor_timeInterval()
# self.cunrrentSFCReliabilityList = self.SFC_reliability_caculating()
# 清空列表
unreliableSFCList = []
unreliableSFCReliabilityList = []
SFCReliabilityMonitorInstance = SFCReliabilityMonitor()
# 存储全网中所有SFC的可靠性
"""此处是死循环的出现地点，下边的代码不会执行"""
# SFCReliabilityList = SFCReliabilityMonitorInstance.reliability_monitor() #怀疑这一句是调用错了，调用的应该是下边的方法
# SFCReliabilityList = SFCReliabilityMonitorInstance.SFC_reliability_caculating()
# 全网中所有SFC的ID列表
ALLSFCList = sfcListSingleton.getSFCList()
# 存储的是网络中SFC的最小可靠性需求值
SFCReliabilityResqeustList = []
for i in range(len(ALLSFCList)):
print("SFC的ID是： %d" % ALLSFCList[i])
print(
"sfcListSingleton.dict_minReliability[ALLSFCList[i]] is: %f"
% sfcListSingleton.dict_minReliability[ALLSFCList[i]])
SFCReliabilityResqeustList.append(
sfcListSingleton.dict_minReliability[ALLSFCList[i]])
print("SFCReliabilityResqeustList is :")
print(SFCReliabilityResqeustList)
# 判断每条SFC的可靠性是否低于阈值
for i in range(len(ALLSFCList)):
SFCInstance = SFC(
ALLSFCList[i],
sfcListSingleton.dict_maxDelay[ALLSFCList[i]],
sfcListSingleton.dict_minReliability[ALLSFCList[i]],
sfcListSingleton.dict_VNFList[ALLSFCList[i]],
sfcListSingleton.dict_createdtime[ALLSFCList[i]])
SFCRequestMinReliability = SFCInstance.getRequestMinReliability(
)
print(self.cunrrentSFCReliabilityList[ALLSFCList[i]])
print(SFCReliabilityResqeustList[i])
if (self.cunrrentSFCReliabilityList[ALLSFCList[i]] <
sfcListSingleton.dict_minReliability[ALLSFCList[i]]
): #可靠性小于需求值
# 将此SFC加入到不满足可靠性要求的SFC列表中
unreliableSFCList.append(ALLSFCList[i])
unreliableSFCReliabilityList.append(
self.cunrrentSFCReliabilityList[ALLSFCList[i]])
judgeMigrationTimeInstance = JudgeMigrationTime()
ifNeedMigration = judgeMigrationTimeInstance.ifNeedMigration(
unreliableSFCList)
# 调用JudgeMigrationTime类中的ifNeedMigration方法，判断此时是否需要进行迁移 unreliableSFCReliabilityList)
if (ifNeedMigration == True):
# 判断是迁移一条还是多条SFC,migrationOneOrMore()方法
if (judgeMigrationTimeInstance.migrationOneOrMore(
unreliableSFCList,
unreliableSFCReliabilityList) == True):
# 迁移某一条SFC
"""调用迁移一条SFC的方法，迁移可靠性低于阈值的SFC列表中的第一条SFC，调用方法处"""
print(
"*****************迁移一条SFC*************************"
)
VNFMigration_instance = VNFMigration()
VNFMigration_instance.migrateVNFsofOneSFC()
else:
judgeMigrationTimeInstance = JudgeMigrationTime()
neededMigrationSFCList = judgeMigrationTimeInstance.getNeededMigrationSFCList(
)
"""调用迁移多条SFC的方法，方法调用处"""
print(
"*****************迁移多条SFC*************************"
)
VNFMigration_instance = VNFMigration()
VNFMigration_instance.migrateVNFsofMultiSFCIterator()
# 睡眠相应的时间间隔之后才再一次去测量
time.sleep(sleepTime)
# 睡眠时间
sleepTime = timeIntervalVariable
print("sleeptime = %d" % sleepTime)
# 每次都要更新
timeIntervalVariable = self.reliability_monitor_timeInterval()
# 存储的是当前网络中SFC的可靠性
self.cunrrentSFCReliabilityList = self.SFC_reliability_caculating()
endtime = time.perf_counter()
print("结束时间：%d" % endtime)
self.count += 1
print("count = %d" % self.count)
# print("%d" % int(endtime - self.starttime))
if (int(endtime - self.starttime) >= 30):
break