def receive_data(self,data):
global original_size
global received_size
Sim.trace('AppHandler',"application got %d bytes" % (len(data)))
self.f.write(data)
received_size += len(data)
self.f.flush()
def retransmit(self,event):
if self.send_base >= len(self.send_buffer):
return
Sim.trace("%d's retransmission timer fired" % (self.source_address))
self.loss_detected()
packet = self.send_one_packet(self.send_base)
self.timer = Sim.scheduler.add(delay=self.timeout, event='retransmit', handler=self.retransmit)
def main():
# parameters
Sim.scheduler.reset()
Sim.set_debug("Node")
# setup network
net = Network("test2network.txt")
for hostname, node in sorted(net.nodes.iteritems()):
node.add_protocol(protocol="dvrouting", handler=RoutingApp(node))
n3 = net.get_node("n3")
n3.add_protocol(protocol="delay", handler=DelayHandler())
p = Packet(destination_address=n3.get_address("n2"),
ident=1,
protocol="delay",
length=1000)
n2 = net.get_node("n2")
Sim.scheduler.add(delay=1.2, event=p, handler=n2.send_packet)
Sim.scheduler.add(delay=1.6, event=None, handler=n2.get_link("n3").down)
Sim.scheduler.add(delay=1.6, event=None, handler=n3.get_link("n2").down)
p = Packet(destination_address=n3.get_address("n2"),
ident=2,
protocol="delay",
length=1000)
Sim.scheduler.add(delay=6.6, event=p, handler=n2.send_packet)
# run the simulation
Sim.scheduler.run()
def handle_packet(self,packet):
# handle ACK
if packet.ack_number > self.window_start and packet.ack_number <= self.sequence:
# this acks new data, so advance the window with slide_window()
Sim.trace("%d received My_RTP ACK from %d for %d" % (packet.destination_address,packet.source_address,packet.ack_number))
self.slide_window(packet.ack_number)
# handle data
if packet.length > 0:
self.pkts_rcvd += 1
Sim.trace("%d received My_RTP segment from %d for %d" % (packet.destination_address,packet.source_address,packet.sequence))
# if the packet is the one we're expecting increment our
# ack number and add the data to the receive buffer
if packet.sequence >= self.ack:
self.receive_buffer.append(packet)
if packet.sequence == self.ack:
self.receive_buffer = sorted(self.receive_buffer, key=lambda TCPPacket: TCPPacket.sequence)
while self.receive_buffer and (self.ack == self.receive_buffer[0].sequence):
pkt = self.receive_buffer.pop(0)
self.increment_ack(pkt.sequence + pkt.length)
# deliver data that is in order
self.app.handle_packet(pkt)
# always send an ACK
self.send_ack()
if packet.queueing_delay > self.pkt_q_delay_threshold:
self.queueing_delay += packet.queueing_delay
print "\n[Average Queuing Delay so far:", str(self.queueing_delay / self.pkts_rcvd) + "]"
print "\n[Total Queueing Delay so far:", str(self.queueing_delay) + "]\n"
def handle_ack(self, packet):
Sim.trace("%d received ReliableTransport ACK from %d for %d" % (packet.destination_address,packet.source_address,packet.ack_number))
self.unacked_packet_count -= ((packet.ack_number - self.received_ack_number) / self.mss)
self.cancel_timer()
self.timer = Sim.scheduler.add(delay=self.timeout, event='new_ack_data', handler=self.retransmit)
self.received_ack_number = packet.ack_number
self.send_if_possible()
def send_one_packet(self, sequence):
if sequence >= len(self.send_buffer):
return
if sequence + self.mss > len(self.send_buffer):
body = self.send_buffer[sequence : ]
else:
body = self.send_buffer[sequence : sequence + self.mss]
# get one packet worth of data
packet = TCPPacket(source_address=self.source_address,
source_port=self.source_port,
destination_address=self.destination_address,
destination_port=self.destination_port,
body=body,
sequence=sequence,ack_number=self.ack)
# send the packet
Sim.trace("%d sending My_RTP segment to %d for %d" % (self.source_address,self.destination_address,packet.sequence))
self.transport.send_packet(packet)
# set a timer
if not self.timer_set:
self.timer = Sim.scheduler.add(delay=self.timeout, event='retransmit', handler=self.retransmit)
self.timer_set = True
return packet
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
net = Network('../networks/one-hop.txt')
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'),link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'),link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = StopAndWait(t1,n1.get_address('n2'),1,n2.get_address('n1'),1,a)
c2 = StopAndWait(t2,n2.get_address('n1'),1,n1.get_address('n2'),1,a)
# send a file
with open(self.filename,'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
def main():
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
net = Network('../networks/five-nodes.txt')
# get nodes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n3 = net.get_node('n3')
n4 = net.get_node('n4')
n5 = net.get_node('n5')
# setup broadcast application
b1 = BroadcastApp(n1)
n1.add_protocol(protocol="broadcast", handler=b1)
b2 = BroadcastApp(n2)
n2.add_protocol(protocol="broadcast", handler=b2)
b3 = BroadcastApp(n3)
n3.add_protocol(protocol="broadcast", handler=b3)
b4 = BroadcastApp(n4)
n4.add_protocol(protocol="broadcast", handler=b4)
b5 = BroadcastApp(n5)
n5.add_protocol(protocol="broadcast", handler=b5)
# send a broadcast packet from 1 with TTL 2, so everyone should get it
p = Packet(source_address=n1.get_address('n2'),
destination_address=0,
ident=1,
ttl=2,
protocol='broadcast',
length=100)
Sim.scheduler.add(delay=0, event=p, handler=n1.send_packet)
# send a broadcast packet from 1 with TTL 1, so just nodes 2 and 3
# should get it
p = Packet(source_address=n1.get_address('n2'),
destination_address=0,
ident=2,
ttl=1,
protocol='broadcast',
length=100)
print("this is an address of n2", n1.get_address('n3'))
Sim.scheduler.add(delay=1, event=p, handler=n1.send_packet)
# send a broadcast packet from 3 with TTL 1, so just nodes 1, 4, and 5
# should get it
p = Packet(source_address=n3.get_address('n1'),
destination_address=0,
ident=3,
ttl=1,
protocol='broadcast',
length=100)
Sim.scheduler.add(delay=2, event=p, handler=n3.send_packet)
# run the simulation
Sim.scheduler.run()
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
n1 = Node()
n2 = Node()
l = Link(address=1,startpoint=n1,endpoint=n2,queue_size=self.queue_size,bandwidth=10000000,propagation=0.01,loss=self.loss, printOut=True)
n1.add_link(l)
n1.add_forwarding_entry(address=2,link=l)
l = Link(address=2,startpoint=n2,endpoint=n1,queue_size=self.queue_size,bandwidth=10000000,propagation=0.01,loss=self.loss)
n2.add_link(l)
n2.add_forwarding_entry(address=1,link=l)
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler("2_1-" + self.filename)
# setup connection
c1 = My_RTP(t1,1,1,2,1,a)
c2 = My_RTP(t2,2,1,1,1,a)
# setup application
a = AppHandler("2_2-" + self.filename)
# setup connection
c3 = My_RTP(t1,1,2,2,2,a)
c4 = My_RTP(t2,2,2,1,2,a)
# send a file
with open(self.filename,'r') as f:
while True:
data = f.read(1000)
if not data:
break
c1.load_buffer(data)
c3.load_buffer(data)
c1.set_file_prefix("2_1")
c2.set_file_prefix("2_1")
c3.set_file_prefix("2_2")
c4.set_file_prefix("2_2")
c1.open_window_file()
c3.open_window_file()
Sim.scheduler.add(delay=0, event="window_init", handler=c1.window_init)
Sim.scheduler.add(delay=0, event="window_init", handler=c3.window_init)
# run the simulation
Sim.scheduler.run()
n1.links[0].myfile.close()
c1.close_window_file()
c3.close_window_file()
Sim.close_rate_file()
def main():
# parameters
Sim.scheduler.reset()
Sim.set_debug("Node")
# setup network
net = Network("test3network.txt")
for hostname, node in sorted(net.nodes.iteritems()):
node.add_protocol(protocol="dvrouting", handler=RoutingApp(node))
n7 = net.get_node("n7")
n7.add_protocol(protocol="delay", handler=DelayHandler())
n10 = net.get_node("n10")
n10.add_protocol(protocol="delay", handler=DelayHandler())
n15 = net.get_node("n15")
n15.add_protocol(protocol="delay", handler=DelayHandler())
n8 = net.get_node("n8")
n11 = net.get_node("n11")
n12 = net.get_node("n12")
p1 = Packet(destination_address=n7.get_address("n6"),
ident=1,
protocol="delay",
length=1000)
Sim.scheduler.add(delay=4.2, event=p1, handler=n12.send_packet)
p3 = Packet(destination_address=n15.get_address("n14"),
ident=2,
protocol="delay",
length=1000)
Sim.scheduler.add(delay=4.3, event=p3, handler=n11.send_packet)
p2 = Packet(destination_address=n10.get_address("n1"),
ident=3,
protocol="delay",
length=1000)
Sim.scheduler.add(delay=4.4, event=p2, handler=n8.send_packet)
n2 = net.get_node("n2")
Sim.scheduler.add(delay=4.8, event=None, handler=n2.get_link("n8").down)
Sim.scheduler.add(delay=4.8, event=None, handler=n8.get_link("n2").down)
p4 = Packet(destination_address=n10.get_address("n1"),
ident=4,
protocol="delay",
length=1000)
Sim.scheduler.add(delay=10.4, event=p4, handler=n8.send_packet)
Sim.scheduler.add(delay=10.8, event=None, handler=n2.get_link("n8").up)
Sim.scheduler.add(delay=10.8, event=None, handler=n8.get_link("n2").up)
p5 = Packet(destination_address=n10.get_address("n1"),
ident=5,
protocol="delay",
length=1000)
Sim.scheduler.add(delay=16.4, event=p5, handler=n8.send_packet)
# run the simulation
Sim.scheduler.run()
def run(self):
drop_packets = [14000, 26000, 28000]
Sim.set_debug('Plot')
# setup network
net = Network('basic.txt')
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
plotter = Plotter()
for i in range(0, 4):
application = AppHandler(self.filename)
Sim.scheduler.reset()
Sim.files = {}
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
application,
fast_retransmit=True,
drop=drop_packets[:i])
TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
application,
fast_retransmit=True)
# send a file
with open(self.filename, 'rb') as f:
while True:
data = f.read()
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
Sim.scheduler.run()
for filename, file in Sim.files.iteritems():
file.close()
plotter.sequence("sequence" + str(i + 1) + ".png")
plotter.cwnd("cwnd" + str(i + 1) + ".png")
self.diff()
def send_ack(self):
packet = TCPPacket(source_address=self.source_address,
source_port=self.source_port,
destination_address=self.destination_address,
destination_port=self.destination_port,
sequence=self.sequence,ack_number=self.ack, flow_id=int(self.file_prefix.split("_")[-1]))
# send the packet
Sim.trace("%d sending My_RTP ACK to %d for %d" % (self.source_address,self.destination_address,packet.ack_number))
self.transport.send_packet(packet)
def send_ack(self):
packet = TCPPacket(source_address=self.source_address,
source_port=self.source_port,
destination_address=self.destination_address,
destination_port=self.destination_port,
sequence=self.sequence,ack_number=self.ack)
# send the packet
Sim.trace("%d sending ReliableTransport ACK to %d for %d" % (self.source_address,self.destination_address,packet.ack_number))
self.transport.send_packet(packet)
def send_cumulative_ack(self):
sequences = sorted(self.receive_temp_buffer)
for i in range(self.ack/self.mss, len(sequences)):
if sequences[i] == self.ack:
pkt = self.find_packet(self.ack)
self.increment_ack(pkt.sequence + pkt.length)
self.app.handle_packet(pkt)
Sim.trace_custom("%d %d" % (pkt.sequence, pkt.length), 'rate', self.source_port)
self.send_ack()
def run(self):
# parameters
Sim.scheduler.reset()
if "a" in self.debug:
Sim.set_debug('AppHandler')
if "t" in self.debug:
Sim.set_debug('TCP')
# setup network
networkPlotter = Plotter('out/2-flows-simple')
net = Network(config='networks/one-hop.txt',plotter=networkPlotter)
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'),link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'),link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup connection
c1 = TCP(t1,n1.get_address('n2'),1,n2.get_address('n1'),1,AppHandler(inputfile=self.inputfile,identifier="c1"),window=self.window,type=self.type,window_size_plot=True,sequence_plot=True)
c2 = TCP(t2,n2.get_address('n1'),1,n1.get_address('n2'),1,AppHandler(inputfile=self.inputfile,plot=True,identifier="c2"),window=self.window,type=self.type,receiver_flow_plot=True)
c3 = TCP(t1,n1.get_address('n2'),2,n2.get_address('n1'),2,AppHandler(inputfile=self.inputfile,identifier="c3"),window=self.window,type=self.type,window_size_plot=True,sequence_plot=True)
c4 = TCP(t2,n2.get_address('n1'),2,n1.get_address('n2'),2,AppHandler(inputfile=self.inputfile,plot=True,identifier="c4"),window=self.window,type=self.type,receiver_flow_plot=True)
global tcps
tcps = [c1, c2, c3, c4]
global original_size
f = open(self.inputfile, "rb")
try:
data = f.read(1000)
while data != "":
original_size += len(data)
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
Sim.scheduler.add(delay=0, event=data, handler=c3.send)
data = f.read(1000)
finally:
f.close()
# run the simulation
global decisecondEvent
decisecondEvent = Sim.scheduler.add(delay=0.1, event=Sim, handler=self.decisecond)
Sim.scheduler.run()
networkPlotter.plot(self.sequencefile)
plotter.plot(self.sequencefile);
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
# setup network
net = Network('network.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a,
window=self.window,
fast_retransmit=self.fast_retransmit)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a,
window=self.window,
fast_retransmit=self.fast_retransmit)
# send a file
with open(self.filename, 'rb') as f:
while True:
data = f.read(10000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
if self.print_queueing_delay:
print('average queueing delay: {}'.format(
c2.total_queueing_delay / c2.total_packets_received))
def send_ack(self):
packet = TCPPacket(source_address=self.source_address,
source_port=self.source_port,
destination_address=self.destination_address,
destination_port=self.destination_port,
sequence=self.next_sequence_num,ack_number=self.ack)
# since we are sending ACK, we're not waiting to send cumulative ACK anymore
self.next_inorder_seg_pending = False
# send the packet
Sim.trace("SEND ACK: %d ===> %d : %d" % (self.source_address,self.destination_address,packet.ack_number))
self.transport.send_packet(packet)
def run(self, fila, drop):
self.filename = fila
fast = True
Sim.trace('Trans', "It is %s that I am using drop transmit." % (fast))
Sim.set_debug("Plot")
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
Sim.set_debug('Trans')
# setup network
net = Network('network.txt')
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = TCP(t1, n1.get_address('n2'), 1, n2.get_address('n1'), 1, a, drop)
c2 = TCP(t2, n2.get_address('n1'), 1, n1.get_address('n2'), 1, a, drop)
# send a file
with open(self.filename, 'rb') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
self.diff()
self.filename = None
return Sim.scheduler.current_time()
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
# Sim.set_debug('Link')
# setup application
a = AppHandler(self.filename, self.out_directory)
# setup network
net = Network('../networks/setup.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a,
window=self.window)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a,
window=self.window)
# send a file
with open(self.in_directory + '/' + self.filename, 'r') as f:
while True:
data = f.read(10000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
def handle_packet(self,packet):
# handle ACK (Sender)
# if the ACK number is greater than our send base...
# update the acknowledged segment counter, restart timer and send if possible
if packet.ack_number > self.send_base:
Sim.trace("ACK RCVD: %d <=== %d : %d" % (packet.destination_address,packet.source_address,packet.ack_number))
self.not_yet_acknowledged_segments -= ((packet.ack_number - self.send_base) / self.mss)
self.cancel_timer()
self.timer = Sim.scheduler.add(delay=self.timeout, event='new_ack_data', handler=self.retransmit)
self.send_base = packet.ack_number
self.send_if_possible()
else:
self.triple_dup_ack_counter+=1
if self.triple_dup_ack_counter == 3:
Sim.trace("FAST RETRANSMIT: Duplicate ACK: %d"%(packet.ack_number))
Sim.trace("Outstanding acks: %d" % self.not_yet_acknowledged_segments)
self.send_one_packet(packet.ack_number)
self.triple_dup_ack_counter = 0
# handle data (Receiver)
if packet.length > 0:
Sim.trace("SEGMENT RCVD: %d <=== %d : %d" % (packet.destination_address,packet.source_address,packet.sequence))
self.receive_temp_buffer.add(packet.sequence)
self.receive_packet_buffer.append(packet)
self.send_cumulative_ack()
def retransmit(self,event):
self.timer_set = False
if self.packets_outstanding <= 0:
return
self.ssthresh = int(max(math.ceil(self.window_size / 2.0), 1))
self.window_size = 1
self.bytes_acked = 0
self.packets_outstanding = 1
Sim.trace("%d retransmission timer fired" % (self.source_address))
packet = self.send_one_packet(self.window_start)
if packet:
self.sequence = self.window_start + packet.length
self.window_file.write(str(Sim.scheduler.current_time()) + " " + str(self.window_size) + "\n")
def send_one_packet(self, sequence):
# get one packet worth of data
body = self.send_buffer[sequence:(sequence + self.mss)]
packet = TCPPacket(source_address=self.source_address,
source_port=self.source_port,
destination_address=self.destination_address,
destination_port=self.destination_port,
body=body,
sequence=sequence,ack_number=self.ack)
# send the packet
Sim.trace("%d sending ReliableTransport segment to %d for %d" % (self.source_address,self.destination_address,packet.sequence))
self.transport.send_packet(packet)
# set a timer if it's not already going
if not self.timer:
self.timer = Sim.scheduler.add(delay=self.timeout, event='retransmit', handler=self.retransmit)
return packet
def handle_sequence(self, packet):
# print "We want sequence number:%d\nGot sequence number:%d\n" % (self.ack, packet.sequence)
Sim.trace("%d received ReliableTransport segment from %d for %d" % (packet.destination_address,packet.source_address,packet.sequence))
ReliableTransport.stats.add(packet.queueing_delay)
self.received_sequences.add(packet.sequence)
self.receive_buffer.append(packet)
# cumulative ack
sequence_list = sorted(self.received_sequences)
for i in range(self.ack/self.mss, len(sequence_list)):
if sequence_list[i] == self.ack:
tempPacket = [p for p in self.receive_buffer if p.sequence == self.ack][0]
self.increment_ack(tempPacket.sequence + tempPacket.length)
self.app.handle_packet(tempPacket)
self.send_ack()
def handle_ack(self, packet):
print >> self.ack_file, Sim.scheduler.current_time(), packet.ack_number, packet.length
Sim.trace("%d received TcpTahoe ACK from %d for %d" % (packet.destination_address,packet.source_address,packet.ack_number))
new_bytes = packet.ack_number - self.received_ack_number
self.unacked_packet_count -= new_bytes
if self.cwnd >= self.threshold:
self.cwnd += (self.mss*new_bytes)/self.cwnd
self.threshold = self.cwnd
else:
self.cwnd += new_bytes
self.cancel_timer()
self.timer = Sim.scheduler.add(delay=self.timeout, event='new_ack_data', handler=self.retransmit)
self.send_if_possible()
self.received_ack_number = packet.ack_number
def handle_sequence(self, packet):
print >> self.sequence_file, Sim.scheduler.current_time(), packet.ack_number, packet.length
Sim.trace("%d received TcpTahoe segment from %d for %d" % (packet.destination_address,packet.source_address,packet.sequence))
self.received_sequences.add(packet.sequence)
self.receive_buffer.append(packet)
# cumulative ack
sequence_list = sorted(self.received_sequences)
for i in range(self.ack/self.mss, len(sequence_list)):
if sequence_list[i] == self.ack:
tempPacket = [p for p in self.receive_buffer if p.sequence == self.ack][0]
self.increment_ack(tempPacket.sequence + tempPacket.length)
print >> self.rate_file, Sim.scheduler.current_time(), self.ack, tempPacket.length
self.app.handle_packet(tempPacket)
self.send_ack()
def receive_data(self,data):
if self.plot:
global original_size
global received_size
Sim.trace('AppHandler',"application got %d bytes" % (len(data)))
self.f.write(data)
received_size[self.identifier] += len(data)
self.f.flush()
turn_timer_off = True
for identifier in received_size.keys():
if received_size[identifier] != original_size:
turn_timer_off = False
break
if turn_timer_off:
global decisecondEvent
Sim.scheduler.cancel(decisecondEvent)
def run(self):
# parameters
Sim.scheduler.reset()
if "a" in self.debug:
Sim.set_debug('AppHandler')
if "t" in self.debug:
Sim.set_debug('TCP')
# setup network
net = Network('networks/one-hop.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'),link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'),link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.inputfile)
# setup connection
c1 = TCP(t1,n1.get_address('n2'),1,n2.get_address('n1'),1,a,window=self.window,type=self.type)
c2 = TCP(t2,n2.get_address('n1'),1,n1.get_address('n2'),1,a,window=self.window,type=self.type)
global original_size
f = open(self.inputfile, "rb")
try:
data = f.read(1000)
while data != "":
original_size += len(data)
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
data = f.read(1000)
finally:
f.close()
# run the simulation
Sim.scheduler.run()
plotter.plot(self.sequencefile);
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug(False)
# setup network
n1 = Node()
n2 = Node()
l = Link(address=1,startpoint=n1,endpoint=n2,loss=self.loss,bandwidth=100000000,propagation=0.01)
if self.experiments:
l = Link(address=1,startpoint=n1,endpoint=n2,loss=self.loss,bandwidth=100000000,propagation=0.01, queue_size=100)
n1.add_link(l)
n1.add_forwarding_entry(address=2,link=l)
l = Link(address=2,startpoint=n2,endpoint=n1,loss=self.loss,bandwidth=100000000,propagation=0.01)
if self.experiments:
l = Link(address=2,startpoint=n2,endpoint=n1,loss=self.loss,bandwidth=100000000,propagation=0.01, queue_size=100)
n2.add_link(l)
n2.add_forwarding_entry(address=1,link=l)
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = ReliableTransport(t1,1,1,2,1,self.window_size,a)
c2 = ReliableTransport(t2,2,1,1,1,self.window_size,a)
# send a file
with open(self.filename,'r') as f:
c1.stats.set_size(os.path.getsize(self.filename))
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
print "Average queueing delay =", c1.stats.average()
print "Throughput =", c1.stats.throughput(Sim.scheduler.current_time())
def exp3():
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
net = Network('../networks/l4e3.txt')
# get nodes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n3 = net.get_node('n3')
n4 = net.get_node('n4')
n5 = net.get_node('n5')
n6 = net.get_node('n6')
n7 = net.get_node('n7')
n8 = net.get_node('n8')
n9 = net.get_node('n9')
n10 = net.get_node('n10')
n11 = net.get_node('n11')
n12 = net.get_node('n12')
n13 = net.get_node('n13')
n14 = net.get_node('n14')
n15 = net.get_node('n15')
# setup broadcast application
p_setup(n1)
p_setup(n2)
p_setup(n3)
p_setup(n4)
p_setup(n5)
p_setup(n6)
p_setup(n7)
p_setup(n8)
p_setup(n9)
p_setup(n10)
p_setup(n11)
p_setup(n12)
p_setup(n13)
p_setup(n14)
p_setup(n15)
# run the simulation
Sim.scheduler.run()
def send_one_packet(self,sequence):
# get one packet worth of data
body = self.send_buffer[sequence:(sequence + self.mss)]
packet = TCPPacket(source_address=self.source_address,
source_port=self.source_port,
destination_address=self.destination_address,
destination_port=self.destination_port,
body=body,
sequence=sequence,ack_number=self.ack)
# send the packet
Sim.trace("SEND SEGMENT: %d ===> %d : %d at %d" % (self.source_address,self.destination_address,packet.sequence,packet.enter_queue))
self.transport.send_packet(packet)
Sim.trace("SENT AT: %d" % packet.enter_queue)
if not self.timer:
self.timer = Sim.scheduler.add(delay=self.timeout, event='retransmit', handler=self.retransmit)
return packet
def receive_data(self,data):
if self.plot:
global original_size
global received_size
Sim.trace('AppHandler',"application got %d bytes" % (len(data)))
self.f.write(data)
received_size[self.identifier] += len(data)
self.f.flush()
turn_timer_off = True
for identifier in received_size.keys():
if received_size[identifier] != original_size:
turn_timer_off = False
break
if turn_timer_off:
global decisecondEvent
Sim.scheduler.cancel(decisecondEvent)
global previous_decisecond_stored_size
bytes_per_second = (original_size - previous_decisecond_stored_size[self.identifier]) / Sim.scheduler.current_time()
#print "Bytes per second: ", bytes_per_second
self.add_plot_data(Sim.scheduler.current_time(),bytes_per_second,'ReceiverRate',self.identifier)
def handle_packet(self,packet):
# handle ACK (Sender)
# if the ACK number is greater than our send base...
# update the acknowledged segment counter, restart timer and send if possible
if packet.ack_number > self.send_base:
Sim.trace("ACK RCVD: %d <=== %d : %d" % (packet.destination_address,packet.source_address,packet.ack_number))
bytes_acked = packet.ack_number - self.send_base
self.not_yet_acknowledged_segments -= bytes_acked
if self.cwnd >= self.ssthreshold:
self.cwnd += (self.mss * bytes_acked) / self.cwnd
else:
self.cwnd += bytes_acked
self.cancel_timer()
self.timer = Sim.scheduler.add(delay=self.timeout, event='new_ack_data', handler=self.retransmit)
self.send_if_possible()
self.send_base = packet.ack_number
# print congestion window
if self.source_port > 3:
Sim.trace_custom("%f" % (self.cwnd/self.mss), 'cwnd', self.source_port)
# handle data (Receiver)
if packet.length > 0:
Sim.trace("SEGMENT RCVD: %d <=== %d : %d" % (packet.destination_address,packet.source_address,packet.sequence))
self.receive_temp_buffer.add(packet.sequence)
self.receive_packet_buffer.append(packet)
self.send_cumulative_ack()
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
# setup network
net = Network('../networks/one-hop.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'),link=n1.links[0]) # n1 -> n2
n2.add_forwarding_entry(address=n1.get_address('n2'),link=n2.links[0]) # n1 <- n2
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
tcp_flows = 1
a1 = AppHandler(self.filename, 1)
# setup connection
c1a = TCP(t1, n1.get_address('n2'), 1, n2.get_address('n1'), 1, 3000, a1)
c2a = TCP(t2, n2.get_address('n1'), 1, n1.get_address('n2'), 1, 3000, a1)
# send a file
with open(self.filename,'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1a.send)
# run the simulation
Sim.scheduler.run()
return tcp_flows
def main():
# parameters
Sim.scheduler.reset()
Sim.set_debug("Node")
# setup network
net = Network("test1network.txt")
for hostname, node in sorted(net.nodes.iteritems()):
node.add_protocol(protocol="dvrouting", handler=RoutingApp(node))
n5 = net.get_node("n5")
n5.add_protocol(protocol="delay", handler=DelayHandler())
p = Packet(destination_address=n5.get_address("n4"),
ident=1,
protocol="delay",
length=1000)
n1 = net.get_node("n1")
Sim.scheduler.add(delay=3.2, event=p, handler=n1.send_packet)
# run the simulation
Sim.scheduler.run()
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
n1 = Node()
n2 = Node()
l = Link(address=1,startpoint=n1,endpoint=n2,loss=self.loss,
bandwidth=10000000.0,propagation=0.01,queue_size=self.queue)
n1.add_link(l)
n1.add_forwarding_entry(address=2,link=l)
l = Link(address=2,startpoint=n2,endpoint=n1,loss=self.loss,
bandwidth=10000000.0,propagation=0.01,queue_size=self.queue)
n2.add_link(l)
n2.add_forwarding_entry(address=1,link=l)
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = TCP(t1,1,1,2,1,app=a,window=self.window)
c2 = TCP(t2,2,1,1,1,app=a,window=self.window)
# send a file
with open(self.filename,'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
print "Total queuing delay: ", a.total_queuing_delay
print "Total packets sent: ", a.total_packets_sent
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
n1 = Node()
n2 = Node()
l = Link(address=1,startpoint=n1,endpoint=n2,queue_size=self.queue_size,bandwidth=10000000,propagation=0.01,loss=self.loss)
n1.add_link(l)
n1.add_forwarding_entry(address=2,link=l)
l = Link(address=2,startpoint=n2,endpoint=n1,queue_size=self.queue_size,bandwidth=10000000,propagation=0.01,loss=self.loss)
n2.add_link(l)
n2.add_forwarding_entry(address=1,link=l)
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = My_RTP(t1,1,1,2,1,a)
c2 = My_RTP(t2,2,1,1,1,a)
# send a file
with open(self.filename,'r') as f:
while True:
data = f.read(1000)
if not data:
break
c1.load_buffer(data)
c1.window_init(self.window_size)
# run the simulation
Sim.scheduler.run()
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
Sim.set_debug('Plot')
# setup network
net = Network('./networks/one-hop.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a,
window=self.window,
drop=self.drops)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a,
window=self.window,
drop=self.drops)
# setup fast retransmit
if self.fast_retransmit:
c1.set_fast_retransmit_enabled(True)
c2.set_fast_retransmit_enabled(True)
# send a file
with open(self.filename, 'rb') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
# setup network
net = Network('basic.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = TCP(t1, n1.get_address('n2'), 1, n2.get_address('n1'), 1, a, window=self.window, fast_retransmit=self.fast_retransmit)
TCP(t2, n2.get_address('n1'), 1, n1.get_address('n2'), 1, a, window=self.window, fast_retransmit=self.fast_retransmit)
# send a file
with open(self.filename, 'rb') as f:
while True:
data = f.read()
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
Sim.scheduler.run()
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
n1 = Node()
n2 = Node()
l = Link(address=1,startpoint=n1,endpoint=n2,loss=self.loss)
n1.add_link(l)
n1.add_forwarding_entry(address=2,link=l)
l = Link(address=2,startpoint=n2,endpoint=n1,loss=self.loss)
n2.add_link(l)
n2.add_forwarding_entry(address=1,link=l)
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = StopAndWait(t1,1,1,2,1,a)
c2 = StopAndWait(t2,2,1,1,1,a)
# send a file
with open(self.filename,'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
def exp1():
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
net = Network('../networks/l4e1.txt')
# get nodes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n3 = net.get_node('n3')
n4 = net.get_node('n4')
n5 = net.get_node('n5')
# setup broadcast application
p_setup(n1)
p_setup(n2)
p_setup(n3)
p_setup(n4)
p_setup(n5)
#send to every node from n1
p = Packet(destination_address=n2.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n1.send_packet)
p = Packet(destination_address=n3.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n1.send_packet)
p = Packet(destination_address=n4.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n1.send_packet)
p = Packet(destination_address=n5.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n1.send_packet)
#send to every node from n2
p = Packet(destination_address=n1.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n2.send_packet)
p = Packet(destination_address=n5.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n2.send_packet)
p = Packet(destination_address=n3.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n2.send_packet)
p = Packet(destination_address=n4.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n2.send_packet)
#send to every node from n3
p = Packet(destination_address=n1.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n3.send_packet)
p = Packet(destination_address=n2.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n3.send_packet)
p = Packet(destination_address=n4.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n3.send_packet)
p = Packet(destination_address=n5.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n3.send_packet)
#send to every node from n4
p = Packet(destination_address=n2.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n4.send_packet)
p = Packet(destination_address=n1.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n4.send_packet)
p = Packet(destination_address=n3.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n4.send_packet)
p = Packet(destination_address=n5.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n4.send_packet)
#send to every node from n5
p = Packet(destination_address=n2.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n5.send_packet)
p = Packet(destination_address=n3.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n5.send_packet)
p = Packet(destination_address=n4.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n5.send_packet)
p = Packet(destination_address=n1.get_address('n1'),
ident=1,
protocol='delay',
length=1000)
Sim.scheduler.add(delay=5, event=p, handler=n5.send_packet)
# run the simulation
Sim.scheduler.run()
def plot_sequence(self,sequence,event):
if self.node.hostname =='n1':
Sim.plot('sequence.csv','%s,%s,%s\n' % (Sim.scheduler.current_time(),sequence,event))
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
# Sim.set_debug('Link')
# setup application
a1 = AppHandler(self.filename + str(1), self.out_directory)
a2 = AppHandler(self.filename + str(2), self.out_directory)
a3 = AppHandler(self.filename + str(3), self.out_directory)
a4 = AppHandler(self.filename + str(4), self.out_directory)
a5 = AppHandler(self.filename + str(5), self.out_directory)
# setup network
net = Network('../networks/setup.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a1,
window=self.window)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a1,
window=self.window)
# setup connection
c3 = TCP(t1,
n1.get_address('n2'),
2,
n2.get_address('n1'),
2,
a2,
window=self.window)
c4 = TCP(t2,
n2.get_address('n1'),
2,
n1.get_address('n2'),
2,
a2,
window=self.window)
# setup connection
c5 = TCP(t1,
n1.get_address('n2'),
3,
n2.get_address('n1'),
3,
a3,
window=self.window)
c6 = TCP(t2,
n2.get_address('n1'),
3,
n1.get_address('n2'),
3,
a3,
window=self.window)
# setup connection
c7 = TCP(t1,
n1.get_address('n2'),
4,
n2.get_address('n1'),
4,
a4,
window=self.window)
c8 = TCP(t2,
n2.get_address('n1'),
4,
n1.get_address('n2'),
4,
a4,
window=self.window)
# setup connection
c9 = TCP(t1,
n1.get_address('n2'),
5,
n2.get_address('n1'),
5,
a5,
window=self.window)
c0 = TCP(t2,
n2.get_address('n1'),
5,
n1.get_address('n2'),
5,
a5,
window=self.window)
# send a file
with open(self.in_directory + '/' + self.filename, 'r') as f:
while True:
data = f.read(10000)
if not data:
break
Sim.scheduler.add(delay=0.0, event=data, handler=c1.send)
Sim.scheduler.add(delay=0.1, event=data, handler=c3.send)
Sim.scheduler.add(delay=0.2, event=data, handler=c5.send)
Sim.scheduler.add(delay=0.3, event=data, handler=c7.send)
Sim.scheduler.add(delay=0.4, event=data, handler=c9.send)
# run the simulation
Sim.scheduler.run()
def plot_window_header(self):
if self.node.hostname == 'n1':
Sim.plot('cwnd.csv','Time,Congestion Window,Threshold,Event\n')
def receive_data(self, data):
Sim.trace('AppHandler', "application got %d bytes" % (len(data)))
self.f.write(data)
self.f.flush()
def plot_window(self, event):
if self.node.hostname == 'n1':
Sim.plot('cwnd.csv', '%s,%s,%s,%s\n' % (Sim.scheduler.current_time(), self.window, self.threshold, event))
def trace(self, message, protocol=""):
Sim.trace("Node" + protocol, message + " (" + protocol + ")")
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
# setup network
if self.use_queue:
net = Network('networks/one-hop-queue.txt')
else:
net = Network('networks/one-hop.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a,
window=self.window,
threshold=self.threshold,
fast_recovery=self.fast_recovery)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a,
window=self.window,
threshold=self.threshold,
fast_recovery=self.fast_recovery)
# send a file
with open(self.filename, 'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
# print some results
print
print "========== Overall results =========="
time = Sim.scheduler.current_time()
print "Total time: %f seconds" % time
avg = numpy.mean(c2.queueing_delay_list)
print "Average queueing delay: %f" % avg
max = numpy.max(c2.queueing_delay_list)
print "Max queueing delay: %f" % max
file_size = os.path.getsize(self.filename)
print "File size: %i" % file_size
throughput = file_size / time
print "Throughput: %f" % throughput
print "%i,%f,%f,%f,%i,%f\n" % (self.window, time, avg, max, file_size,
throughput)
if self.loss == 0.0:
print "Outputing results to experiment.csv"
output_fh = open('experiment.csv', 'a')
output_fh.write(
"%i,%f,%f,%f,%i,%f\n" %
(self.window, time, avg, max, file_size, throughput))
output_fh.close()
print "Saving the sequence plot"
self.create_sequence_plot(c1.x, c1.y, c1.dropX, c1.dropY, c1.ackX,
c1.ackY)
import random
from dvrouting import DVRoutingApp
class HandleDataApp(object):
def __init__(self,node):
self.node = node
def receive_packet(self,packet):
print Sim.scheduler.current_time(),self.node.hostname,"received data"
if __name__ == '__main__':
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
Sim.set_debug('Nodedata')
# setup network
net = Network('networks/five-nodes-ring.txt')
# get nodes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n3 = net.get_node('n3')
n4 = net.get_node('n4')
n5 = net.get_node('n5')
# setup handling data for node 5
n1.add_protocol(protocol="data",handler=HandleDataApp(n1))
n2.add_protocol(protocol="data",handler=HandleDataApp(n2))
def trace(self, message):
""" Print debugging messages. """
Sim.trace("TCP", message)
def receive_data(self,data):
Sim.trace('AppHandler',"application got %d bytes" % (len(data)))
self.f.write(data)
self.f.flush()
def run(self):
# parameters
Sim.scheduler.reset()
#Sim.set_debug('AppHandler')
#Sim.set_debug('TCP')
Sim.set_debug('Link')
net = Network('networks/one.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a1 = AppHandler('test.txt')
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a1,
window=self.window,
threshold=self.threshold,
fast_recovery=True,
aimdc=5.0 / 6.0)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a1,
window=self.window,
threshold=self.threshold,
fast_recovery=True,
aimdc=5.0 / 6.0)
# send a file
with open('test.txt', 'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
# print some results
print
print "========== Overall results =========="
time = Sim.scheduler.current_time()
print "Total time: %f seconds" % time
avg = numpy.mean(c2.queueing_delay_list)
print "Average queueing delay: %f" % avg
max = numpy.max(c2.queueing_delay_list)
print "Max queueing delay: %f" % max
file_size = os.path.getsize(self.filename)
print "File size: %i" % file_size
throughput = file_size / time
print "Throughput: %f" % throughput
plotter = Plotter()
print "Saving the sequence plot"
plotter.create_sequence_plot(c1.x,
c1.y,
c1.dropX,
c1.dropY,
c1.ackX,
c1.ackY,
chart_name='advanced/aimd/sequence.png')
plotter.clear()
plotter.rateTimePlot(c2.packets_received, Sim.scheduler.current_time(),
'advanced/aimd/rateTime1.png')
linkab = n1.links[0]
self.linkab = linkab
plotter.clear()
plotter.queueSizePlot(linkab.queue_log_x,
linkab.queue_log_y,
linkab.dropped_packets_x,
linkab.dropped_packets_y,
chart_name='advanced/aimd/queueSize.png')
plotter.clear()
plotter.windowSizePlot(c1.window_x,
c1.window_y,
chart_name="advanced/aimd/windowSize1.png")
def plot_cwnd_header(self):
if self.node.hostname == 'n1':
Sim.plot('cwnd.csv', 'Time,Congestion Window\n')
def plot_cwnd(self):
if self.node.hostname == 'n1':
Sim.plot(
'cwnd.csv',
'%s,%s\n' % (Sim.scheduler.current_time(), int(self.cwnd)))
def main():
Sim.set_debug('Node')
# run_five_nodes_line()
run_five_nodes_ring()
def trace(self, message):
''' Print debugging messages. '''
Sim.trace("TCP", message)
def run(self):
# parameters
Sim.scheduler.reset()
#Sim.set_debug('AppHandler')
#Sim.set_debug('TCP')
Sim.set_debug('Link')
net = Network('networks/two.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a1 = AppHandler('test1.txt')
a2 = AppHandler('test2.txt')
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a1,
window=self.window,
threshold=self.threshold,
fast_recovery=self.fast_recovery)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a1,
window=self.window,
threshold=self.threshold,
fast_recovery=self.fast_recovery)
c3 = TCP(t1,
n1.get_address('n2'),
2,
n2.get_address('n1'),
2,
a2,
window=self.window,
threshold=self.threshold,
fast_recovery=self.fast_recovery)
c4 = TCP(t2,
n2.get_address('n1'),
2,
n1.get_address('n2'),
2,
a2,
window=self.window,
threshold=self.threshold,
fast_recovery=self.fast_recovery)
# send a file
with open('test1.txt', 'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
with open('test2.txt', 'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c3.send)
# run the simulation
Sim.scheduler.run()
# print some results
print
print "========== Overall results =========="
time = Sim.scheduler.current_time()
print "Total time: %f seconds" % time
avg = numpy.mean(c2.queueing_delay_list)
print "Average queueing delay: %f" % avg
max = numpy.max(c2.queueing_delay_list)
print "Max queueing delay: %f" % max
file_size = os.path.getsize(self.filename)
print "File size: %i" % file_size
throughput = file_size / time
print "Throughput: %f" % throughput
# Variables for debugging
self.c3 = c3
self.c4 = c4
self.c2 = c2
self.c1 = c1
self.t1 = t1
self.t2 = t2
self.net = net
linkab = n1.links[0]
self.linkab = linkab
l = linkab
# Plotting
plotter = Plotter()
# Plot sequence charts
plotter.clear()
plotter.create_sequence_plot(c1.x,
c1.y,
c1.dropX,
c1.dropY,
c1.ackX,
c1.ackY,
chart_name='two/sequence1.png')
plotter.clear()
plotter.create_sequence_plot(c3.x,
c3.y,
c3.dropX,
c3.dropY,
c3.ackX,
c3.ackY,
chart_name='two/sequence2.png')
# Plot receiver rate
plotter.clear()
plotter.rateTimePlot(c2.packets_received,
Sim.scheduler.current_time(),
chart_name=None)
plotter.rateTimePlot(c4.packets_received,
Sim.scheduler.current_time(),
chart_name='two/rateTime.png')
# Plot queue size
plotter.clear()
plotter.queueSizePlot(l.queue_log_x,
l.queue_log_y,
l.dropped_packets_x,
l.dropped_packets_y,
chart_name='two/queueSize.png')
# Plot congestion window
plotter.clear()
plotter.windowSizePlot(c1.window_x,
c1.window_y,
chart_name="two/windowSize1.png")
plotter.clear()
plotter.windowSizePlot(c3.window_x,
c3.window_y,
chart_name="two/windowSize2.png")
import random
class BroadcastApp(object):
def __init__(self, node):
self.node = node
def receive_packet(self, packet):
print Sim.scheduler.current_time(), self.node.hostname, packet.ident
if __name__ == '__main__':
# parameters
Sim.scheduler.reset()
Sim.set_debug(True)
# setup network
net = Network('networks/five-nodes.txt')
# get nodes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n3 = net.get_node('n3')
n4 = net.get_node('n4')
n5 = net.get_node('n5')
# setup broadcast application
b1 = BroadcastApp(n1)
n1.add_protocol(protocol="broadcast", handler=b1)
b2 = BroadcastApp(n2)
def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
#Sim.set_debug('TCP')
Sim.set_debug('Link')
net = Network('networks/one-hop-queue.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename)
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a,
window=self.window,
threshold=self.threshold,
fast_recovery=self.fast_recovery)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a,
window=self.window,
threshold=self.threshold,
fast_recovery=self.fast_recovery)
# send a file
with open(self.filename, 'r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
# print some results
print
print "========== Overall results =========="
time = Sim.scheduler.current_time()
print "Total time: %f seconds" % time
avg = numpy.mean(c2.queueing_delay_list)
print "Average queueing delay: %f" % avg
max = numpy.max(c2.queueing_delay_list)
print "Max queueing delay: %f" % max
file_size = os.path.getsize(self.filename)
print "File size: %i" % file_size
throughput = file_size / time
print "Throughput: %f" % throughput
plotter = Plotter()
#print "Saving the sequence plot"
#plotter.create_sequence_plot(c1.x, c1.y, c1.dropX, c1.dropY, c1.ackX, c1.ackY)
self.c2 = c2
self.c1 = c1
self.t1 = t1
self.t2 = t2
self.net = net
plotter.rateTimePlot(c2.packets_received, Sim.scheduler.current_time(),
'one/rateTime.png')
def run(self):
# parameters
Sim.scheduler.reset()
#Sim.set_debug('AppHandler')
#Sim.set_debug('TCP')
Sim.set_debug('Link')
net = Network('networks/five.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'),link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'),link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a1 = AppHandler('test1.txt')
a2 = AppHandler('test2.txt')
a3 = AppHandler('test3.txt')
a4 = AppHandler('test4.txt')
a5 = AppHandler('test5.txt')
# setup connection
c1 = TCP(t1,n1.get_address('n2'),1,n2.get_address('n1'),1,a1,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c2 = TCP(t2,n2.get_address('n1'),1,n1.get_address('n2'),1,a1,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c3 = TCP(t1,n1.get_address('n2'),2,n2.get_address('n1'),2,a2,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c4 = TCP(t2,n2.get_address('n1'),2,n1.get_address('n2'),2,a2,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c5 = TCP(t1,n1.get_address('n2'),3,n2.get_address('n1'),3,a3,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c6 = TCP(t2,n2.get_address('n1'),3,n1.get_address('n2'),3,a3,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c7 = TCP(t1,n1.get_address('n2'),4,n2.get_address('n1'),4,a4,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c8 = TCP(t2,n2.get_address('n1'),4,n1.get_address('n2'),4,a4,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c9 = TCP(t1,n1.get_address('n2'),5,n2.get_address('n1'),5,a5,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
c0 = TCP(t2,n2.get_address('n1'),5,n1.get_address('n2'),5,a5,window=self.window,threshold=self.threshold,fast_recovery=self.fast_recovery)
# send a file
with open('test1.txt','r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
with open('test2.txt','r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=1.5, event=data, handler=c3.send)
with open('test3.txt','r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=2, event=data, handler=c5.send)
with open('test4.txt','r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=2.5, event=data, handler=c7.send)
with open('test5.txt','r') as f:
while True:
data = f.read(1000)
if not data:
break
Sim.scheduler.add(delay=3, event=data, handler=c9.send)
# run the simulation
Sim.scheduler.run()
# print some results
print
print "========== Overall results =========="
time = Sim.scheduler.current_time()
print "Total time: %f seconds" % time
avg = numpy.mean(c2.queueing_delay_list)
print "Average queueing delay: %f" % avg
max = numpy.max(c2.queueing_delay_list)
print "Max queueing delay: %f" % max
file_size = os.path.getsize(self.filename)
print "File size: %i" % file_size
throughput = file_size / time
print "Throughput: %f" % throughput
# Variables for debugging
self.c3 = c3
self.c4 = c4
self.c2 = c2
self.c1 = c1
self.t1 = t1
self.t2 = t2
self.net = net
linkab = n1.links[0]
self.linkab = linkab
l = linkab
# Plotting
plotter = Plotter()
# Plot sequence charts
#plotter.clear()
#plotter.create_sequence_plot(c1.x, c1.y, c1.dropX, c1.dropY, c1.ackX, c1.ackY, chart_name='five/sequence1.png')
#plotter.clear()
#plotter.create_sequence_plot(c3.x, c3.y, c3.dropX, c3.dropY, c3.ackX, c3.ackY, chart_name='five/sequence2.png')
# Plot receiver rate
plotter.clear()
plotter.rateTimePlot(c2.packets_received, Sim.scheduler.current_time(), chart_name='five/rateTime1.png')
plotter.rateTimePlot(c4.packets_received, Sim.scheduler.current_time(), chart_name='five/rateTime2.png')
plotter.rateTimePlot(c6.packets_received, Sim.scheduler.current_time(), chart_name='five/rateTime3.png')
plotter.rateTimePlot(c8.packets_received, Sim.scheduler.current_time(), chart_name='five/rateTime4.png')
plotter.rateTimePlot(c0.packets_received, Sim.scheduler.current_time(), chart_name='five/rateTime5.png')
# Plot queue size
plotter.clear()
plotter.queueSizePlot(l.queue_log_x, l.queue_log_y, l.dropped_packets_x, l.dropped_packets_y, chart_name='five/queueSize.png')
def plot_sequence_header(self):
if self.node.hostname =='n1':
Sim.plot('sequence.csv','Time,Sequence Number,Event\n')
