I have to write a reliable multi-threaded file server over (unreliable) udp for simultaneous file transfer of files from the server to the client.

I wanted to start coding but we're getting graded based on efficiency and a number of questions came up.

First we're using a sliding window protocol with 2 byte sequence numbers to implement reliable in order delivery to the upper level protocol.

My question is since the window size should be slightly larger than the delay bandwith product what do you think the best way to measure the delay would be?

My partner and I originally planned on sending a request for what we call a delay determing packet (DDP), and then sending ten of these DDPs, and taking the average of what arrives, and then sending that result back to the other side using stop and wait. This way both sides get the measured delay.

An alternative idea came up however that really avoids all this handshaking (which would be superior for small files where delay dominates anyway) The idea was to start with a default window size and then have a variable length window at the server and to calculate the delay based upon the time acks are received. Of course the receiver would have to have an unnecessarily large window size in order to avoid having to have a variable length window sizeThis seems complex but does anyone think it might be better?

Second solution should be better. In the first case you assume that delay will be tha same during the whole transmission. It's usually true for short ones, but for longer it's not (you can also have packets lost etc). Second solutions allows you to change, as the network changes.

If you *really* wanted a good grade, you'd implement *both* and chart the efficiencies under:

1. High bandwidth/low latency (e.g. LAN) vs Low bandwidth/high latency(e.g. dialup) bandwidth
... and ...
2. Small (1-20 byte) vs large (512 byte - 1K) payloads

It's not necessarily as much work as it might sound like.

And you'd probably come up with a cleaner design by figuring out how to "factor out" the "window-size" protocol from the rest of your send/receive code.

Please consider it!

PS:
Refer to Stevens (Unix Network Programming) and Tanenbaum (Computer Networks, 3rd Ed), too. They've both got some interesting "tips" on flow control issues!