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))