This is an intermediate Chameleon implementation of the ADI.
This is organized not by send/receive, but by protocol and 
capabilities.  These are all in separate files:

    Protocol    Blocking?            Filename
    Rendezvous  Yes                  chbrndv.c
    Rendezvous  No                   chnrndv.c
    Eager       Yes                  chbeager.c
    Eager       No                   chneager.c
    Get         -                    chget.c
    Put         -                    - not implemented -

Each of these contains routines for

   The blocking operations
   send
   expected recv
   unexpected recv (start and complete)

   For the nonblocking operations, 	
   isend
   irecv
   cancel send
   cancel recv
   test send
   test recv
   wait send
   wait recv

All have unique names so that multiple modules can be used in a single 
executable.  These are

    MPID_<DEVICE>_<PROTOCOL><BLOCKING>_<FUNCTION>

For example

    MPID_TCP_Rndvb_send (Rendezvous blocking send for TCP)

<DEVICE> is specified for each ADI.
<PROTOCOL> is Rndv, Eager, Get
<BLOCKING> is b (blocking) or n (nonblocking)

<FUNCTION> is 

   send 	- send
   isend        - isend
   recv         - expected recv
   irecv        - irecv
   uxrecv       -  unexpected recv (start and complete)
   cancel_send	- cancel send
   cancel_recv 	- cancel recv
   test_send	- test send
   test_recv	- test recv
   wait_send	- wait send
   wait_recv	- wait recv

Question:  The "b" value refers to the underlying transfer (channel)
operation.  Do we also need isend, irecv, etc?  How are short/long messages
handled?


All receives happen by getting the initial packet.  The "recv" routine here
is passed the packet, and completes the receive of the message.

It might help to have a common package of files for the case of short, eager
messages (in packet).

This special file is chshort.c (always eager and short).
It contains only send, recv, and unxrecv.

What these files do is to give a common interface to the data transport layer.
In some sense ALL they do is add the packet structure and the mode for moving
data.  These routines are still driven by a separate routine that determines
who to send to/receive from and what protocol to use.

They should be encapsulated into a structure, which should include properties
like "has nonblocking" or "my name is".  
