예제 #1
0
파일: tcp.py 프로젝트: Steve525/bene
    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()
예제 #2
0
파일: my_rtp.py 프로젝트: mkeagar/cs460
	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"
예제 #3
0
파일: my_rtp.py 프로젝트: mkeagar/cs460
	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
예제 #4
0
 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()
예제 #5
0
파일: tcp.py 프로젝트: Steve525/bene
 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)
예제 #6
0
 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()
예제 #7
0
파일: my_rtp.py 프로젝트: mkeagar/cs460
	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)
예제 #8
0
 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)
예제 #9
0
파일: tcp.py 프로젝트: Steve525/bene
 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)
예제 #10
0
    def run(self, janela, perda, fila, fast):

        self.filename = fila
        loss = perda
        Sim.trace('Trans', "It is %s that I am using fast transmit." % (fast))

        # parameters
        Sim.scheduler.reset()
        Sim.set_debug('AppHandler')
        Sim.set_debug('TCP')
        Sim.set_debug('Trans')

        # setup network
        net = Network('./network.txt')
        net.loss(loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        net.set_queue(n1.links[0], "100")
        net.set_queue(n2.links[0], "100")

        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,
                 janela, fast)
        c2 = TCP(t2, n2.get_address('n1'), 1, n1.get_address('n2'), 1, a,
                 janela, fast)

        # 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()
예제 #11
0
파일: tcp.py 프로젝트: Steve525/bene
 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()
예제 #12
0
파일: my_rtp.py 프로젝트: mkeagar/cs460
	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")
예제 #13
0
 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)
예제 #14
0
    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()
예제 #15
0
파일: tcp.py 프로젝트: dallinski/bene
    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()
예제 #16
0
 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
예제 #17
0
파일: tcp.py 프로젝트: dallinski/bene
    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
예제 #18
0
파일: tcp.py 프로젝트: Steve525/bene
 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
예제 #19
0
파일: transfer.py 프로젝트: StevenC4/bene
    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)
예제 #20
0
파일: tcp.py 프로젝트: dallinski/bene
 def loss_event(self):
     Sim.trace("Before loss event: cwnd = %d. Source port = %d" % ((self.cwnd/self.mss), self.source_port))
     self.threshold = max(self.cwnd/2, self.mss)
     self.cwnd = self.mss
     Sim.trace("After  loss event: cwnd = %d. Source port = %d" % ((self.cwnd/self.mss), self.source_port))
예제 #21
0
 def retransmit(self,event):
     if self.received_ack_number < len(self.send_buffer):
         Sim.trace("%d retransmission timer fired" % (self.source_address))
         packet = self.send_one_packet(self.received_ack_number)
         self.timer = Sim.scheduler.add(delay=self.timeout, event='retransmit', handler=self.retransmit)
예제 #22
0
파일: transfer1.py 프로젝트: mkeagar/cs460
 def handle_packet(self,packet):
     Sim.trace("application got packet with %d bytes" % (packet.length))
     self.f.write(packet.body)
     self.f.flush()
예제 #23
0
파일: tahoe.py 프로젝트: ihartung/460-Lab1
 def receive_data(self, data):
     Sim.trace('AppHandler', "application got %d bytes" % (len(data)))
     self.f.write(data)
     self.f.flush()
예제 #24
0
파일: tcpaiad.py 프로젝트: StevenC4/bene
 def trace(self, message):
     """ Print debugging messages. """
     Sim.trace("TCP", message)
예제 #25
0
파일: my_rtp.py 프로젝트: mkeagar/cs460
	def retransmit(self,event):
		self.timer_set = False
		if self.packets_outstanding <= 0:
			return
		Sim.trace("%d retransmission timer fired" % (self.source_address))
		packet = self.send_one_packet(self.window_start)
예제 #26
0
파일: transfer.py 프로젝트: Steve525/bene
 def handle_packet(self,packet):
     Sim.trace("application got packet with %d bytes" % (packet.length))
     self.f.write(packet.body)
     self.f.flush()
     self.total_queuing_delay += packet.queueing_delay
     self.total_packets_sent += 1
예제 #27
0
 def receive_packet(self,packet):
     Sim.trace(str(self.node.hostname) + " packet ID: " + str(packet.ident))
예제 #28
0
 def trace(self, message):
     """ Print debugging messages. """
     Sim.trace("TCP", message)
예제 #29
0
파일: tcp.py 프로젝트: joe-eklund/tcp
 def trace(self, message):
     ''' Print debugging messages. '''
     Sim.trace("TCP", message)
예제 #30
0
 def trace(self, message, protocol=""):
     Sim.trace("Node" + protocol, message + " (" + protocol + ")")
예제 #31
0
파일: tcp.py 프로젝트: StevenC4/bene
 def trace(self,message):
     ''' Print debugging messages. '''
     Sim.trace("TCP",message)
예제 #32
0
파일: five.py 프로젝트: nathand8/bene
 def receive_data(self,data):
     Sim.trace('AppHandler',"application got %d bytes" % (len(data)))
     self.f.write(data)
     self.f.flush()
예제 #33
0
파일: node.py 프로젝트: nathand8/bene
 def trace(self,message,protocol=""):
     Sim.trace("Node"+protocol,message + " ("+protocol+")")