Subject: Re: TCP is/isn't

From: [email-masked]
Date: Wed, 9 Nov 94 09:51:12 MST

Let me just put in a couple of words here.

First, Jon,

Contrary to recent reports, TCP is not in fact dead.  TCP is exactly right
for those things for which it is exactly right.  And (guess what?), TCP is
exactly wrong for those things for which it is exactly wrong.

There may be some question of the delineation between right and wrong here,
but the order of magnitude on both sides is "large".  TCP isn't going to go
away, nor should it.  On the other hand, "other" "elastic" transports
aren't going to go away either (in fact, it is clear that these transports
are going to increase).

Second, Curtis,

Assume i run NFS, say, over TCP.  Assume further that the style i run it is
"if the application asks for 20 bytes of data, i'll read 20 bytes of data
across the network".  Then, this is not going to perform well.  And, it
isn't going to be *because* of TCP that this performs poorly.  This is just
an effect of how "application requests" are transformed into "network
requests" (poorly, in this case).

This is something most file system protocols have been struggling with over
the past N years.  (We, for example, have improved the situation somewhat
by requesting larger blocks of data - which, of course, is approximately
the only answer since, as Dave Clark says, "latency is fundamental".)

Thus, i wouldn't worry so much about what the transport protocol is
*called*, but i *would* insist that it be a good internet citizen.  And, i
would focus some attention on the *use* of the transport by the application
above it.

Greg

---

From: Curtis Villamizar <[email-masked]>
Date: Wed, 09 Nov 1994 12:42:51 -0500

> requests" (poorly, in this case).

NFS doesn't work this way.  It transfers 8 kB blocks by default,
unually 4 kB or less only if you have braindead PC ethernet adapters
with 8kB or less memory on the card.  When you write, the filesystem
delayed write goes into effect if asynchronous write is enabled, so if
you write 20 bytes 8192 times 20 8 kB blocks are transferred when a
filesystem synch occurs (which translates into a TCP stream).  NFS
works quite well over TCP from what I've read (I haven't personnally
used it).

> the only answer since, as Dave Clark says, "latency is fundamental".)

AFS and NFS over TCP do a nice job.  Locking is a very hard problem
though.

> would focus some attention on the *use* of the transport by the application

AFS has characteristics somewhat similar to TCP.  I used to have a URL
of the paper describing the flow control added to AFS (can someone
help me with this?).  I don't think AFS responds to congestion as well
as TCP.  Protocols with fixed windows do a very poor job of making use
of available bandwidth and responding appropriately to congestion.

Curtis