We'll now look at just one fairly simple increase in complexity, an important consideration to be sure, but even this is going to be taken in isolation from all of the other possible avenues we waved our hands at just now, and what we'll do with the one we take is going to be fairly simplistic, itself:

Effect of finite packet size

We assumed, just now, that the message we gave the network was going to be handled as a non-divisible unit: the whole message, as sent by our application, would be handed over in-bulk to the network, which would treat it as a single element all the way to the other end, where it would be handed, unbroken and pristine, to the receiver.

HA!

Once you've given the message to your own operating system, especially if your message is a large one, it's likely that, before it's even left your machine, your message has been chopped up into, shall we say, more managable units. Let's see the formula first, define whatever new terms are needed, and then see what it adds to our understanding of the process:

• C = floor( M / S) x (L + K + S / B) + L + K + (M mod S) / B

  S

  packet length (bytes)

  The size of the segments that your message has been split into.

  K

  overhead for forming and routing packet (seconds)

  How long it takes to do the segmenting and arranging for the packets to be sent along the proper route.

  In words: for each segment, add the latency and the packet-formation and -routing overhead to the time it takes the segment to go through the pipe, and multiply that by the number of segments that your message will completely fill (that's the floor); add to that the same quantity again based on taking care of whatever part of your message doesn't take a full segment to handle (this is the part that the floor didn't cover).

• Stair-step effect in message transmission times

  Here we're emphasizing the fact that it's not your message that gets transmitted, but really the envelopes that your message was split up among ... just as each individual page of a letter you mail doesn't get individually handled by the Post Office, but just the envelope that you put them into, and if you have too many pages for a single envelope, you stuff as many as will fit into one, then do the same for the next, and so on, until you have no pages left. And, just as with these letters, the amount you pay goes up as a function of the number of letters you send.

• Analogous to register length effects on vector machines

  As registers have increased in size from bits to nybbles to bytes to floats to doubles (some are now heading towards 128 bits, or double-double), the same kinds of effects have been observed, because the vector operations are based on the contents of the entire register, not simply on the bits that fill them.

• Can be important for TCP/IP based message passing libraries

  Remember that brief exposure to the 7-tiered ISO communication hierarchy? TCP/IP occupies a middle-portion of that structure, and the exercise we've just been through is going to be complicated for just about every layer in it, as they've all got their own segment length specifications, for the most part. This isn't done capriciously, but rather with regard to the characteristics of the devices that handle each particular layer, and the kinds of information that have to be added on or stripped off at each stage.

  Regardless, segmentation is an inescapable fact of life in network communications, and one of the most costly.