def ack_received(self, packet):
# check for timed-out unacknowledge packets
for (packet_id, dup_num) in self.no_ack.keys():
send_time = self.no_ack[(packet_id, dup_num)]
time_diff = clock.clk.get_time(
) - send_time # need current time!!!!
if time_diff > self.timeout:
del self.no_ack[(packet_id, dup_num)]
self.time_out.append((packet_id, dup_num))
# setup for retransmission
if len(self.time_out) > 0:
self.retransmit = True
self.cwnd /= 2
else:
self.retransmit = False
if self.wake_event != None:
self.event_scheduler.cancel_event(self.wake_event)
# delete acknowledged packet
if (packet.id, packet.dup_num) in self.no_ack.keys():
del self.no_ack[(packet_id, dup_num)]
if self.state == slow_start:
self.cwnd += 1
if self.cwnd >= self.ssthresh:
self.state == congestion_avoidance
elif self.state == congestion_avoidance:
if packet.next_id == self.last_received_ack:
self.dup_count += 1
if (self.dup_count == 3) and (packet.next_id in [
key[0] for key in self.no_ack.keys()
]):
self.cwnd /= 2
self.ssthresh = self.cwnd
self.state = fast_recovery
else:
self.cwnd += 1 / self.cwnd
self.dup_count = 0
elif self.state == fast_recovery:
if packet.next_id == self.last_received_ack:
self.dup_count += 1
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))
return
else:
if packet.id == self.FR_packet:
self.cwnd = ssthresh
self.state = congestion_avoidance
self.dup_count = 0
self.last_received_ack = packet.next_id
self.send_packet()
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))
def wake(self):
if self.state == fast_recovery:
self.state = slow_start
else:
self.cwnd /= 2
for (packet_id, dup_num) in self.no_ack.keys():
send_time = self.no_ack[(packet_id, dup_num)]
time_diff = clock.clk.get_time() - send_time
if time_diff > self.timeout:
del self.no_ack[(packet_id, dup_num)]
self.time_out.append((packet_id, dup_num))
if len(self.time_out) > 0:
self.ssthresh = self.cwnd / 2
#self.state = slow_start
#self.cwnd = 1
#self.no_ack = dict()
self.retransmit = True
else:
self.retransmit = False
print "ajdksfjladksfjlkdsajklfjlkdsajfjlkkjlfdsalkjf33333333333333333333"
print "ajdksfjladksfjlkdsajklfjlkdsajfjlkkjlfdsalkjf33333333333333333333"
print self.cwnd
print "ajdksfjladksfjlkdsajklfjlkdsajfjlkkjlfdsalkjf33333333333333333333"
print "ajdksfjladksfjlkdsajklfjlkdsajfjlkkjlfdsalkjf33333333333333333333"
logger.table.window_log(self.flow.id, self.cwnd, clock.clk.get_time())
flag = self.send_packet()
if (flag == True):
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))
def acknowledgement_received(self, packet):
if self.wake_event != None:
self.event_scheduler.cancel_event(self.wake_event)
# Check if this is a duplicate acknowledgement
if self.last_ack_received == packet.next_id:
self.duplicate_count += 1
keys = [
key for key in self.not_acknowledged.keys()
if key[0] == packet.next_id
]
# After 3 duplicate acknowledgements, if the packet has not
# already been received, it has been dropped so it needs to be re-sent
if (self.duplicate_count == 3) and (len(keys) > 0):
expected = keys[0]
del self.not_acknowledged[(packet.next_id, expected[1])]
self.timed_out.append((packet.next_id, expected[1]))
else:
# reset duplicate count since the chain of dupACKS is broken
self.duplicate_count = 0
self.last_ack_received = packet.next_id
# This acknowledgement is for an unacknowledged packet
if (packet.identifier,
packet.duplicate_num) in self.not_acknowledged.keys():
# calculate RTT of this packet
rtt = self.clock.current_time - self.not_acknowledged[
(packet.identifier, packet.duplicate_num)]
# first packet, initialize base_RTT
if self.base_RTT == -1:
self.base_RTT = rtt
# update window size
self.cwnd = self.cwnd * self.base_RTT / rtt + self.alpha
# update minimum RTT
if rtt < self.base_RTT:
self.base_RTT = rtt
# Remove received packet from list of unacknowledged packets
del self.not_acknowledged[(packet.identifier,
packet.duplicate_num)]
# Check for any unacknowledged packets that have timed out
for (packet_id, dup_num) in self.not_acknowledged.keys():
sent_time = self.not_acknowledged[(packet_id, dup_num)]
time_diff = self.clock.current_time - sent_time
if time_diff > self.timeout:
del self.not_acknowledged[(packet_id, dup_num)]
self.timed_out.append((packet_id, dup_num))
if len(self.timed_out) > 0:
self.retransmit = True
self.cwnd /= 2
else:
self.retransmit = False
self.send_packet()
self.wake_event = self.event_scheduler.delay_event(
self.timeout, FlowWakeEvent(self.flow))
def run(self):
self.queue.current_time = 0
for id in self.flows:
self.queue.put_event(self.flows[id].start_time,
FlowWakeEvent(self.flows[id]))
for id in self.hosts:
self.queue.put_event(5, RoutingUpdateEvent(self.hosts[id]))
while (not self.queue.isEmpty()):
e = self.queue.get_event()
if (e.canceled == False):
#print e
#print clock.clk.get_time()
#a=input()
e.perform()
def wake(self):
# Check for any unacknowledged packets that have timed out
for packet_id in self.not_acknowledged.keys():
sent_time = self.not_acknowledged[packet_id]
time_diff = self.clock.current_time - sent_time
if time_diff > self.timeout:
del self.not_acknowledged[packet_id]
self.timed_out.append(packet_id)
if len(self.timed_out) > 0:
self.retransmit = True
else:
self.retransmit = False
self.cwnd /= 2
self.send_packet()
self.wake_event = self.event_scheduler.delay_event(
self.timeout, FlowWakeEvent(self.flow))
def wake(self):
# Change from fast recovery to slow start phase
if self.state == fast_recovery:
self.state = slow_start
else:
self.cwnd /= 2
# Keep track of timed out packets
for (packet_id, dup_num) in self.not_acknowledged.keys():
sent_time = self.not_acknowledged[(packet_id, dup_num)]
time_diff = self.clock.current_time - sent_time
if time_diff > self.timeout:
del self.not_acknowledged[(packet_id, dup_num)]
self.timed_out.append((packet_id, dup_num))
if len(self.timed_out) > 0:
self.retransmit = True
else:
self.retransmit = False
self.send_packet()
self.wake_event = self.event_scheduler.delay_event(
self.timeout, FlowWakeEvent(self.flow))
def wake(self):
if self.state == fast_recovery:
self.state == slow_start
else:
self.cwnd /= 2
for (packet_id, dup_num) in self.no_ack.keys():
send_time = self.no_ack[(packet_id, dup_num)]
time_diff = clock.clk.get_time() - send_time
if time_diff > self.timeout:
del self.no_ack[(packet_id, dup_num)]
self.timed_out.append((packet_id, dup_num))
if len(self.timed_out) > 0:
self.retransmit = True
else:
self.retransmit = False
self.send_packet()
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))
print "cwnd: ", str(cwnd)
def __init__(self, links, flows, hosts, routers, verbose,
fast_insteadof_reno):
self.links = links
self.flows = flows
self.hosts = hosts
self.routers = routers
# Set up clocks
self.clock = Clock()
for item in flows.values():
item.controller.clock = self.clock
for item in hosts.values():
item.clock = self.clock
# Set up event schedulers
self.event_queue = EventQueue(self.clock)
for flow in flows.values() + links.values() + hosts.values():
flow.event_scheduler = self.event_queue
for flow in flows.values():
flow.controller.event_scheduler = self.event_queue
# Set up initial events
for flow in flows.values():
self.event_queue.delay_event(flow.start_time, FlowWakeEvent(flow))
for host in hosts.values():
self.event_queue.delay_event(0, RoutingUpdateEvent(host))
# Set up logging
self.logger = Logger(self.clock, verbose, fast_insteadof_reno)
for item in flows.values() + links.values() + hosts.values(
) + routers.values():
item.set_logger(self.logger)
# Set up PrintElapsedSimulationTimeEvents
if not verbose: # combining this with verbose mode would be chaos.
self.event_queue.delay_event(
0,
PrintElapsedSimulationTimeEvent(self.clock.current_time,
self.event_queue))
print "Simulation started..."
def wake(self):
#unacknowledged packets that time out
for packet_id in self.no_ack.keys():
sent_time = self.no_ack[packet_id]
time_diff = clock.clk.get_time() - sent_time
if time_diff > self.timeout:
del self.no_ack[packet_id]
self.timed_out.append(packet_id)
# there are timed out packets
if len(self.timed_out) > 0:
self.retransmit = True
else:
self.retransmit = False
############################################
# self.cwnd /= 2
#print "cwnd/2 wake cwnd/2 wake cwnd/2 wake"
#print self.cwnd
#print "cwnd/2 wake cwnd/2 wake cwnd/2 wake"
#logger.table.window_log(self.flow.id, self.cwnd, clock.clk.get_time())
flag = self.send_packet()
if (flag == True):
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))
def acknowledgement_received(self, packet):
# Check for any unacknowledged packets that have timed out
for (packet_id, dup_num) in self.not_acknowledged.keys():
sent_time = self.not_acknowledged[(packet_id, dup_num)]
time_diff = self.clock.current_time - sent_time
if time_diff > self.timeout:
del self.not_acknowledged[(packet_id, dup_num)]
self.timed_out.append((packet_id, dup_num))
# If we have packets that have timed out, we want to retransmit these
if len(self.timed_out) > 0:
self.retransmit = True
self.cwnd /= 2
else:
self.retransmit = False
# Remove the FlowWakeEvent from the event scheduler
if self.wake_event != None:
self.event_scheduler.cancel_event(self.wake_event)
# Remove received packet from list of unacknowledged packets
if (packet.identifier,
packet.duplicate_num) in self.not_acknowledged.keys():
del self.not_acknowledged[(packet.identifier,
packet.duplicate_num)]
# In slow start phase, increase congestion window size by 1
if self.state == slow_start:
self.cwnd += 1
# If congestion window becomes larger than slow start threshold,
# switch to congestion avoidance phase
if self.cwnd >= self.ssthresh:
self.state = congestion_avoidance
elif self.state == congestion_avoidance:
# Check if this is a duplicate acknowledgement
if packet.next_id == self.last_ack_received:
self.duplicate_count += 1
# After 3 duplicate acknowledgements, if the packet has not
# already been received, halve the congestion window size and
# move into fast recovery phase
if (self.duplicate_count == 3) and (packet.next_id in [
key[0] for key in self.not_acknowledged.keys()
]):
self.cwnd /= 2
self.ssthresh = self.cwnd
self.state = fast_recovery
# This is not a duplicate acknowledgement
else:
self.cwnd += 1 / self.cwnd
# reset duplicate count since the chain of dupACKS is broken
self.duplicate_count = 0
elif self.state == fast_recovery:
# Check if this is a duplicate acknowledgement
if packet.next_id == self.last_ack_received:
self.duplicate_count += 1
self.wake_event = self.event_scheduler.delay_event(
self.timeout, FlowWakeEvent(self.flow))
return
else:
# check if this is the ACK for the packet transmitted during Fast Recovery
if packet.identifier == self.FR_packet:
self.cwnd = self.ssthresh
self.state = congestion_avoidance
# reset duplicate count since the chain of dupACKS is broken
self.duplicate_count = 0
self.last_ack_received = packet.next_id
self.send_packet()
self.wake_event = self.event_scheduler.delay_event(
self.timeout, FlowWakeEvent(self.flow))
def ack_received(self, packet):
print "receive"
if self.wake_event != None:
self.event_scheduler.cancel_event(self.wake_event)
# Check if this is a duplicate ack
if packet.next_id == self.last_ack_received:
self.dup_count += 1
keys = [
key for key in self.no_ack.keys() if key[0] == packet.next_id
]
# 3 duplicate ack and packet has not been received, get into fastrecovery state.
if (self.dup_count == 3) and (len(keys) > 0):
self.cwnd /= 2
self.ssthresh = self.cwnd
self.cwnd += 3
self.fastrecovery = True
self.cwnd += 1
if packet.next_id == self.last_received_ack:
self.dup_count += 1
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))
return
else:
if packet.id == self.FR_packet:
self.cwnd = self.ssthresh
self.state = congestion_avoidance
self.dup_count = 0
# not a duplicate ack
else:
self.dup_count = 0
self.last_ack_received = packet.next_id
# ack for unacknowlefged packet
if (packet.id, packet.duplicate_num) in self.no_ack.keys():
#print "waiting input"
#a=input()
#calculate RTT
rtt = clock.clk.get_time() - self.no_ack[(packet.id,
packet.duplicate_num)]
logger.table.packet_delay_log(self.flow.id, rtt,
clock.clk.get_time())
# the first calculated rtt
if self.base_RTT == -1:
self.base_RTT = rtt
# update window size
print self.cwnd
self.cwnd = min(2 * self.cwnd,
(1 - self.gama) * self.cwnd + self.gama *
(self.cwnd * self.base_RTT / rtt + self.alpha))
print "update cwnd ackreceive update cwnd ackreceive"
print rtt
print self.base_RTT
print self.cwnd
print "update cwnd ackreceive update cwnd ackreceive"
logger.table.window_log(self.flow.id, self.cwnd,
clock.clk.get_time())
# update minimum RTT
if rtt < self.base_RTT:
self.base_RTT = rtt
del self.no_ack[(packet.id, packet.duplicate_num)]
# check for timed out packet
for (packet_id, dup_num) in self.no_ack.keys():
sent_time = self.no_ack[(packet_id, dup_num)]
time_diff = clock.clk.get_time() - sent_time
if time_diff > self.timeout:
del self.no_ack[(packet_id, dup_num)]
self.timed_out.append((packet_id, dup_num))
if len(self.timed_out) > 0:
print len(self.timed_out)
a = input("check timed out packet ack_receive")
self.retransmit = True
self.ssthresh = self.cwnd / 2
self.cwnd /= 2
print "cwnd/2 ackreceive cwnd/2 ackreceive cwnd/2 ackreceive"
print self.cwnd
print "cwnd/2 ackreceive cwnd/2 ackreceive cwnd/2 ackreceive"
logger.table.window_log(self.flow.id, self.cwnd,
clock.clk.get_time())
else:
self.retransmit = False
flag = self.send_packet()
if (flag == True):
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))
def ack_received(self, packet):
# check for timed-out unacknowledge packets
print str(self.state)
for (packet_id, dup_num) in self.no_ack.keys():
send_time = self.no_ack[(packet_id, dup_num)]
time_diff = clock.clk.get_time(
) - send_time # need current time!!!!
if time_diff > self.timeout and self.state != fast_recovery:
del self.no_ack[(packet_id, dup_num)]
self.time_out.append((packet_id, dup_num))
# setup for retransmission
if len(self.time_out) > 0:
#a = input()
self.ssthresh = self.cwnd / 2
#self.cwnd = 1
#self.state = slow_start
#self.no_ack = dict()
self.retransmit = True
else:
self.retransmit = False
#if len(self.time_out) == 0:
#self.retransmit = False;
if self.wake_event != None:
self.event_scheduler.cancel_event(self.wake_event)
# delete acknowledged packet
if (packet.id, packet.duplicate_num) in self.no_ack.keys():
rtt = clock.clk.get_time() - self.no_ack[(packet.id,
packet.duplicate_num)]
logger.table.packet_delay_log(self.flow.id, rtt,
clock.clk.get_time())
print "delete no_ack" + str(packet.id) + str(packet.duplicate_num)
del self.no_ack[(packet.id, packet.duplicate_num)]
#if (packet.duplicate_num == 1):
#a = input("del pack dup = 1")
if self.state == slow_start and self.retransmit == False:
self.cwnd += 1
if self.ssthresh != None and self.cwnd >= self.ssthresh:
self.state = congestion_avoidance
elif self.state == congestion_avoidance and self.retransmit == False:
if packet.next_id == self.last_received_ack:
self.dup_count += 1
if (self.dup_count == 3) and (packet.next_id in [
key[0] for key in self.no_ack.keys()
]):
self.cwnd /= 2
self.ssthresh = self.cwnd
self.cwnd += 3
self.state = fast_recovery
else:
self.cwnd += 1 / self.cwnd
self.dup_count = 0
elif self.state == fast_recovery:
#a = input()
print "FR"
self.cwnd += 1
if packet.next_id == self.last_received_ack:
self.dup_count += 1
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))
return
else:
if packet.id == self.FR_packet:
self.cwnd = self.ssthresh
self.state = congestion_avoidance
self.dup_count = 0
self.last_received_ack = packet.next_id
print "ajdksfjladksfjlkdsajklfjlkdsajfjlkkjlfdsalkjf33333333333333333333"
print "ajdksfjladksfjlkdsajklfjlkdsajfjlkkjlfdsalkjf33333333333333333333"
print self.cwnd
print "ajdksfjladksfjlkdsajklfjlkdsajfjlkkjlfdsalkjf33333333333333333333"
print "ajdksfjladksfjlkdsajklfjlkdsajfjlkkjlfdsalkjf33333333333333333333"
logger.table.window_log(self.flow.id, self.cwnd, clock.clk.get_time())
flag = self.send_packet()
self.wake_event = self.event_scheduler.put_event(
self.timeout, FlowWakeEvent(self.flow))