Python[2.7]：ValueError:对关闭的文件执行I/O操作
我在这里搜索过类似的问题，但没有找到解决问题的方法。 我正在编写一个网络模拟，它将调度随机生成的数据包。我正在使用NetworkX创建图形。模拟随机创建数据包，通过min-cut算法找到路径，然后在队列中调度数据包，然后计算平均减速和平均延迟等统计信息。 我认为问题在于我编写的算法函数，因为在多次模拟运行之后的运行期间，它会以不同的错误类型停止。一旦它的ValueError:I/O操作在关闭的文件上，另一次它给我KeyError:3或KeyError:2 我不知道问题出在哪里 我的代码确实很长，但为了更好地找到解决方案，我将附加它。请记住，在GraphMinCut函数中运行一些次之后，错误总是会出现，希望它能澄清这些错误的原因Python[2.7]：ValueError:对关闭的文件执行I/O操作,python,algorithm,Python,Algorithm,我在这里搜索过类似的问题，但没有找到解决问题的方法。 我正在编写一个网络模拟，它将调度随机生成的数据包。我正在使用NetworkX创建图形。模拟随机创建数据包，通过min-cut算法找到路径，然后在队列中调度数据包，然后计算平均减速和平均延迟等统计信息。 我认为问题在于我编写的算法函数，因为在多次模拟运行之后的运行期间，它会以不同的错误类型停止。一旦它的ValueError:I/O操作在关闭的文件上，另一次它给我KeyError:3或KeyError:2 我不知道问题出在哪里 我的代码确实很长，
# -*- coding: utf-8 -*-
import networkx as nx
import random
import matplotlib.pyplot as plt
from operator import itemgetter
NewG=nx.Graph() #this is going to be a connected graph
num_node=5
num_edges=(num_node*(num_node-1))/2
RTrange=10 #release time range
FlowRange=3
nodelist=[]
for i in range(0,num_node):
nodelist.append(i)
NewG.add_nodes_from(nodelist)
for i in range(0,num_node):
for j in range(0,num_node):
if i<>j:
if not NewG.has_edge(i,j) and not NewG.has_edge(j,i):
NewG.add_edge(i,j,weight=1.0)
print (" the new graph have %d number of nodes and %d edges" %
(NewG.number_of_nodes(),NewG.number_of_edges()))
pos=nx.spring_layout(NewG)
colors=range(num_edges)
nx.draw(NewG,pos,node_color='#A0CBE2',edge_color='#A0BF11',width=4,
edge_cmap=plt.cm.Blues,with_labels=True)
plt.savefig("edge_colormap.png") # save as png
plt.show() # display
runs=250
num_pack=10
# ------------begining of mincut function-------
def GraphMincut(G,source,sink,mylist,queue,t,removeEdge):
pointer=queue.head
addEdge=[]
if removeEdge: # any previous unavalable edges need to be
#linked back as long as it hasn't been added to mylist
for x in removeEdge:
a=x[0]
b=x[1]
if (a,b) not in mylist and (b,a) not in mylist:
if not G.has_edge(a,b):
e=(a,b)
addEdge.append(e)
while removeEdge:
removeEdge.pop()
while pointer.time<t and pointer.next<>None:
pointer=pointer.next
if pointer.time==t:
if pointer.data:
for x in pointer.data:
removeEdge.append(x)
if addEdge:
for x in addEdge:
if not G.has_edge(x[0],x[1]):
G.add_edge(x[0],x[1],weight=1.0)
if removeEdge:
G.remove_edges_from(removeEdge)
print "source and sink",source,sink
if nx.edge_connectivity(G,source,sink)==0:
return mylist
else:
MyEdgeList=[]
MyNodeList=[]
MyEdgeList=sorted(nx.minimum_edge_cut(G,source,sink))
MyNodeList=nx.minimum_node_cut(G,source,sink)
print("edge list:",str(MyEdgeList))
print("node list:",str(MyNodeList))
temp=[]
for j in MyEdgeList:
print"j weight:",G[j[0]][j[1]]['weight']
temp.append(G[j[0]][j[1]]['weight'])
v=min(temp)
print "v:",v
new_sink=None
new_source=None
for j in MyEdgeList:
print "J:",j
print"weight:",G[j[0]][j[1]]['weight']
if v==G[j[0]][j[1]]['weight']:
if j[0] in MyNodeList or j[1] in MyNodeList or (source in (j[0],j[1]) and sink in (j[0],j[1])):
print"j in if 1",j
if (source in (j[0],j[1])) or (sink in (j[0],j[1])):
mylist.append((j[0],j[1]))
break
else:
print("j[1]newsourec",j[1])
print("j[0]newsink",j[0])
new_source=j[1]
new_sink=j[0]
mylist.append((j[0],j[1]))
G.remove_edges_from(MyEdgeList)
mylist=GraphMincut(G,new_source,sink,mylist,queue,
t+1,removeEdge)
mylist=GraphMincut(G,source,new_sink,mylist,queue,
t+1,removeEdge)
if source in (j[0],j[1]) and sink in (j[0],j[1]):
return mylist
for i in MyNodeList:
print"i ",i
print"j[0]j[1]",(j[0],j[1])
if i in (j[0],j[1]):
if source in (j[0],j[1]):
new_source=i
new_sink=sink
break
else:
new_sink=i
new_source=source
break
G.remove_edges_from(MyEdgeList)
print"before call --new source and sink:",new_source,new_sink
mylist=GraphMincut(G,new_source,new_sink,mylist,queue,t+1,removeEdge)
return mylist
# ------------------end mincut function------------------
#-------------------packet generator -------------------
def GeneratePacket(source):
Packet={}
Packet['source']=source
sink_choice=nodelist
sink_choice.remove(source)
Packet['sink']= random.choice(sink_choice)
nodelist.append(source)
nodelist.sort()
Packet['weight']=1.0 #random.randrange(2,10)
Packet['computation_time_MC']=0 #initialized Time To Serve variable
Packet['MC_path']=[]
Packet['release_time']=random.randrange(0,RTrange)
Packet['rescheduledTime']=0 # to count the number of times it was
#rescheduled due to unavailable edge at release time
Packet['flow']=random.randrange(1,FlowRange)
return Packet
#-------------------End packet generator -----------------
def Rearrange_Path(path,s):
newpath=[]
length=path.__len__()
for i in range(0,length):
temp=s
for (a,b) in path:
if temp == a:
s=b
newpath.append((a,b))
path.remove((a,b))
else:
if temp==b:
s=a
newpath.append((b,a))
path.remove((a,b))
return newpath
# ------------------ Print packet details -----------------
def ShowPacket(Packet,i):
print "Packet %d has :" %i
print "source :",Packet['source'], "destination :", Packet['sink']
print "release time = :",Packet['release_time']
print "number of flows =",Packet['flow']
print "MC path :",Packet['MC_path']
print "computation time is :",Packet['computation_time_MC']
print "-"*20
# ------------------ End procedure ---------------
# ------------------list classes -----------
class Node(object):
def __init__(self, prev, next):
self.data = []
self.prev = prev
self.next = next
self.time=0
self.packetID=[]
class DoubleList(object):
head = None
tail = None
def __init__(self):
self.head=None
def size(self):
current = self.head
count = 0
while current != None:
count = count + 1
current = current.next
return count
def append_newNode(self, data,position):
new_node = Node( None, None)
if self.head is None:
self.head = self.tail = new_node
new_node.data.append(data)
new_node.time=position
else:
new_node.prev = self.tail
new_node.next = None
self.tail.next = new_node
self.tail = new_node
new_node.time=position
new_node.data.append(data)
def append_packet(self, pID,Rtime):
new_node = Node( None, None)
if self.head is None:
self.head = self.tail = new_node
new_node.packetID.append(pID)
new_node.time=Rtime
else:
new_node.prev = self.tail
new_node.next = None
self.tail.next = new_node
self.tail = new_node
new_node.packetID.append(pID)
new_node.time=Rtime
def append_MiddleNode(self,pID,edge,Rtime,top,bottom):
new_node = Node( None, None)
new_node.prev=top
new_node.next=bottom
top.next=new_node
bottom.prev=new_node
if edge:
new_node.data.append(edge)
new_node.time=Rtime
if pID:
new_node.packetID.append(pID)
def show_all(self):
current_node=self.head
print "Show all scheduled items in event queue :"
while current_node is not None:
print current_node.time , current_node.packetID,
str(current_node.data)
current_node = current_node.next
print "*"*50
# ------------------begin simulation -------------
with open ("resultFile.csv","w") as RF:
RF.write(str(date))
RF.write("\n ")
RF.write("run#,Mean WT MC,Mean WT SPF,Mean SlowD MC, Mean SlowD SPF, Mean THr MC,Mean THr SPF")
RF.write("\n")
with open ("Result.csv","w") as DF: #contains detailed results
DF.write(str(date))
DF.write("\n")
DF.write("run#,original RT, Rescheduled T, current RT, source, sink")
DF.write(",Computation T,#of flows, Start, Finish,Wait \n")
for r in range(0,runs): #simulation run r times
with open ("resultFile.csv","a") as RF:
with open ("Result.csv","a") as DF: #contains detailed results
Packets=[]
for i in range(0,num_pack):#create random packets for the whole
# network
Packets.append({})
packet_Source=random.randrange(0,num_node)
Packets[i]=GeneratePacket(packet_Source)
ShowPacket(Packets[i],i)
# sort packets minimum release time first
Packets.sort(key=itemgetter('release_time'))
print "Packets after sorting by earlist release time -----"
for i in range(0,num_pack):
ShowPacket(Packets[i],i)
# ----- create queue event for (MC)-------
EventQueue = DoubleList()
# initilize statistics parameters
Mean_wait_t_MC=0
Mean_slowdown_MC=0
Mean_Throughput_MC=0
MC_delay_rate=0
MCThroughput=0
MC_slowdown=0
#---inser packets in order in my eventQueue for MC ------------
for i in range(0,num_pack):
R=int(Packets[i]['release_time'])
if EventQueue.size()==0:
EventQueue.append_packet(i,R)
EventQueue.show_all()
else:
current=EventQueue.head
appended= False
for n in range(0,EventQueue.size()):
if current.time==R:
current.packetID.append(i)
EventQueue.show_all()
appended= True
break
else:
current=current.next
if appended==False:
EventQueue.append_packet(i,R)
EventQueue.show_all()
# ---------------------------------
current_Packet=[]
Time_pointer=EventQueue.head
counter=num_pack
while (counter > 0):
if not current_Packet:
while not Time_pointer.packetID and Time_pointer.next<>None:
Time_pointer=Time_pointer.next
current_Packet=Time_pointer.packetID
while current_Packet:
myGraph=nx.Graph()
print"mygraph..initialized"
nx.draw(myGraph)
plt.show(myGraph)
myGraph=NewG.copy()
print"mygraph..after copy"
nx.draw(myGraph)
plt.show(myGraph)
packet_path=[]
x=int(Packets[current_Packet[0]]['source'])
y=int(Packets[current_Packet[0]]['sink'])
ReleaseT=int(Packets[current_Packet[0]]['release_time'])
removeEdge=[]
# here we get the path from Mincut function
GraphMincut(myGraph,x,y,packet_path,EventQueue,ReleaseT,removeEdge)
packet_path=Rearrange_Path(packet_path,x)
p=current_Packet[0]
# incase the packet path was empty list due to unavailable edges at this time
# reschedule the flow by delaying it one time unit
if not packet_path:
print "no available edges at this time release.. delay one time unit"
Packets[p]['release_time']+=1
print "p=",p
R=int(Packets[p]['release_time'])
Packets[p]['rescheduledTime']+=1
current=EventQueue.head
appended= False
for n in range(0,EventQueue.size()):
if current.time==R:
current.packetID.append(p)
current.packetID.sort()
current_Packet.remove(p)
EventQueue.show_all()
appended= True
break
else:
if current.time<R and current.next<> None:
current=current.next
if current.time>R:
EventQueue.append_MiddleNode(p,[],R,current.prev,current)
current_Packet.remove(p)
EventQueue.show_all()
appended= True
break
if appended==False:
EventQueue.append_packet(p,R)
EventQueue.show_all()
current_Packet.remove(p)
break
length= packet_path.__len__()
print"path:",packet_path
print"length: ",length
flow=int(Packets[p]['flow'])
Packets[p]['computation_time_MC']=length+flow-1
Packets[p]['MC_path']=packet_path
original_RT=ReleaseT-int(Packets[p]['rescheduledTime'])
DF.write(" %s," %str(r))
DF.write(" %s," %str(original_RT))
DF.write(" %s," %str(Packets[p]['rescheduledTime']))
DF.write(" %s," %str(Packets[p]['release_time']))
DF.write(" %s," %str(Packets[current_Packet[0]] ['source']))
DF.write(" %s," %str(Packets[current_Packet[0]]['sink']))
DF.write(" %s," %str(length))
DF.write(" %s," %str(flow))
#initilize time variables for MC
Finish_time=0
Start_time=ReleaseT #just to make sure it doesn't start
# b4 it is released
current=EventQueue.head
start= False
counter -=1
end=False
while current.time <Time_pointer.time:
current=current.next
#----begin scheduling events for MC path --------
for i in range(0,flow): # loop to schedule every flow
position=ReleaseT +i
if current.time<>position:
current=EventQueue.head
while current.time <position and current.next<>None:
current=current.next
for j in packet_path:
for k in range(0,EventQueue.size()):
if position==current.time:
a=j[0]
b=j[1]
if (a,b) not in current.data and (b,a)not in current.data:
current.data.append(j)
EventQueue.show_all()
position+=1
if start==False:
start=True
Start_time=current.time
DF.write(" %s,",%str(Start_time))
if current.next <> None:
current=current.next
else:
end=True
break
else:
if current.next==None:
position+=1
EventQueue.append_newNode(j,position)
current=current.next
end=True
break
current=current.next
position+=1
else:
if (position<current.time):
EventQueue.append_MiddleNode([],j,position,current.prev,current)
EventQueue.show_all()
position+=1
if start==False:
start=True
Start_time=current.time
DF.write(" %s,",%str(Start_time))
break
if (position >current.time):
EventQueue.append_newNode(j,position)
EventQueue.show_all()
position+=1
if start==False:
start=True
Start_time=current.time
DF.write(" %s," %str(Start_time))
current=current.next
end=True
break
if end==False:
current=current.prev
Calculate_TT= length + flow -1 # Calculate travel time
#is used to measure travel time between nodes
print "current time is=",current.time
Finish_time=current.time+1
MCThroughput =MCThroughput + (Finish_time - original_RT)
Wait= (Finish_time - original_RT - Calculate_TT)
MC_delay_rate= MC_delay_rate+ Wait
MC_slowdown= MC_slowdown + ((Finish_time -
original_RT)/Calculate_TT)
DF.write(" %s," %str(Finish_time))
DF.write(" %s" %str(Wait))
DF.write("\n ")
print " Start time is ", Start_time
print "Finish time is", Finish_time
print "Computation time is ", Calculate_TT
print " wait time is ",Wait
# now we need to put back the time of release and reschedule to their
#original state to be used again by SPF scheduling (later step)
Packets[p]['rescheduledTime']=0
Packets[p]['release_time']=original_RT
current_Packet.remove(current_Packet[0])
if not Time_pointer.packetID:
for g in range(0,EventQueue.size()):
if not Time_pointer.packetID and
Time_pointer.next<>None:
Time_pointer=Time_pointer.next
else:
break
#------------end scheduling events for MC path
Mean_wait_t_MC= float(MC_delay_rate)/ num_pack
Mean_slowdown_MC= float(MC_slowdown)/num_pack
Mean_Throughput_MC= float(MCThroughput) / num_pack
RF.write(" %s," %str(r))
RF.write(" %s," %str(Mean_wait_t_MC))
RF.write(" %s," %str(Mean_slowdown_MC))
RF.write(" %s," %str(Mean_Throughput_MC) )
RF.write("\n")
del EventQueue
#-*-编码：utf-8-*-
将networkx导入为nx
随机输入
将matplotlib.pyplot作为plt导入
从运算符导入itemgetter
NewG=nx.Graph（）#这将是一个连通图
num_节点=5
num_边=（num_节点*（num_节点-1））/2
RTrange=10#释放时间范围
流量范围=3
节点列表=[]
对于范围内的i（0，num_节点）：
nodelist.append（一）
NewG.add_nodes_from（节点列表）
对于范围内的i（0，num_节点）：
对于范围内的j（0，num_节点）：
如果ij：
如果不是新的有_边（i，j）且不是新的有_边（j，i）：
新建添加_边（i，j，权重=1.0）
打印（“新图形有%d个节点和%d条边”%
（NewG.number_of_nodes（），NewG.number_of_edges（））
位置=nx.弹簧布局（新）
颜色=范围（边数）
nx.绘图（新建，位置，节点颜色='#A0CBE2'，边缘颜色='#A0BF11'，宽度=4，
边缘（cmap=plt.cm.Blues，带标签=True）
plt.savefig（“edge_colormap.png”）#另存为png
plt.show（）#显示
运行次数=250
包数=10
#------mincut函数的开始-------
def GraphMincut（G、源、接收器、mylist、队列、t、removeEdge）：
指针=queue.head
addEdge=[]
如果删除：#需要删除任何以前不可用的边
#只要没有添加到mylist，就可以链接回
对于removeEdge中的x：
a=x[0]
b=x[1]
如果（a，b）不在mylist中且（b，a）不在mylist中：
如果G.没有边缘（a，b）：
e=（a，b）
追加。追加（e）
移除时：
removedge.pop（）
而指针（0.0）：
如果不是当前的_数据包：
而不是Time\u pointer.packetID和Time\u pointer.NEXTONE：
时间指针=时间指针。下一步
当前\u数据包=时间\u指针.packetID
当前_数据包时：
myGraph=nx.Graph（）
打印“mygraph..initialized”
nx.draw（myGraph）
plt.show（myGraph）
myGraph=NewG.copy（）
打印“mygraph..after copy”
nx.draw（myGraph）
plt.show（myGraph）
数据包路径=[]
x=int（数据包[当前数据包[0]['source']）
y=int（数据包[当前_数据包[0]][sink']）
ReleaseT=int（数据包[当前数据包[0]]['release\u time']）
removeEdge=[]
#这里我们从Mincut函数得到路径
GraphMincut（myGraph、x、y、数据包路径、事件队列、ReleaseT、removeEdge）
数据包路径=重新排列路径（数据包路径，x）
p=当前_数据包[0]
#如果由于此时边缘不可用，数据包路径为空列表
#通过将流程延迟一次来重新安排流程
如果不是数据包路径：
打印“此时无可用边缘发布..延迟一个时间单位”
数据包[p]['release_time']+=1
打印“p=”，p
R=int（数据包[p]['release_time']）
数据包[p]['rescheduledTime']+=1
当前=EventQueue.head
追加=错误
对于范围（0，EventQueue.size（））中的n：
如果当前.time==R：
current.packetID.append（p）
current.packetID.sort（）
当前_数据包。删除（p）
EventQueue.show_all（）
追加=真
打破
其他：
如果当前为.timeR：
EventQueue.append\u MiddleNode（p，[]，R，current.prev，current）
当前_数据包。删除（p）
EventQueue.show_all（）
追加=真
打破
如果追加==False：
EventQueue.append_数据包（p，R）
EventQueue.show_all（）
当前_数据包。删除（p）
打破
长度=数据包路径
打印“路径：”，数据包路径
打印“长度：”，长度
flow=int（数据包[p]['flow']）
数据包[p]['computation\u time\u MC']=length+flow-1
数据包[p]['MC_路径']=数据包_路径
原始\u RT=ReleaseT int（数据包[p]['rescheduledTime']）
写入（“%s，”%str（r））
写（“%s，”%str（原件））
写入（“%s，”%str（数据包[p]['rescheduledTime']））
写入（“%s”，%str（数据包