[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

packets dropped at the source




Hello,

is there a difference in the way a TCP source in ns is dealing with packets
when the buffer is full toward a real implementation of TCP?

ns
----
- if TCP needs to send 2 packets for example, and the buffer has space
  for only 1 packet, ns put one packet in the queue and drop the other
  (before transmission).
  The TCP source will know about the dropped packets only when it will
  receive dupacks.

TCP implementation
-------------------
Two different implementations (or a parameter to be set):
1-the TCP program at the transport layer sends 2 packets to the link layer,
  where the buffer is. The link layer puts one packet in the queue and
  leaves the function call in a waiting state, until the buffer has enough 
  space for the remaining packets (1 in this case).
  So no packets are dropped (at the source).

2-the TCP program at the transport layer sends 2 packets to the link layer,
  where the buffer is. The link layer puts one packet in the queue and
  returns to the function at the transport layer the number of bytes 
  (packets) written to the the buffer. It drops the other packets (1).
  Even if it drops the packets the TCP source comes to know this from the 
  return value of the function, and doesn't need to wait for dupacks.

Is this is correct?
It doesn't make sense that the source drops the packets because its buffer
is full and doesn't know about this, and it has to wait untill dupacks and 
so on.

Thanks,

	Anna & Gurudatt