itaps-parallel Assignments for parallel interface, due before 2/5 phone conf

[Vitus Leung]

On Tue, 2008-02-05 at 10:45 -0700, Devine, Karen D wrote:
> Vitus:  Thanks for the corrections and sorry for the confusion.  I think
> these calls need some sort of "message tag" (analogous to MPI's message tag)
> that allows sends and receives to be interwoven.  Also, we should consider
> whether we need a post/send/wait model as Onkar described.
> 
> Karen

Actually, no confusion.  Good suggestion o the "message tag" that would
allow sends and receives to be interwoven and better support the
post/send/wait model that Onkar suggested.  Also, good suggestions from
Onkar on ghosts and Par in name.  However, I still think that the two
calls are sufficient.

void prefix_sendEntArrToPartsPar(iMesh_Instance instance,
                       /*in*/  const prefix_PartitionHandle partition_handle,
                       /*in*/  const iBase_EntityHandle *entity_handles,
                       /*in*/  const int entity_handles_size,
                       /*in*/  const int *target_part_ids,
                       /*in*/  int command_code,  // e.g., MIGRATE,COPY
		       /*in*/  int update_ghost,  // e.g., YES,NO
		       /*in*/  int message_tag,
                               int *err);

// The implementation has everything it needs to determine sends and 
// receives.  It can send and post non-blocking receives.  Upon return, 
// the application can do other stuff for latency hiding.

void prefix_receiveEntArrToPartsPar(iMesh_Instance instance,
                       /*in*/  const prefix_PartitionHandle partition_handle,
                    /*inout*/  iBase_EntityHandle **entity_handles,
                    /*inout*/  int *entity_handles_size,
                      /*out*/  int *entity_handles_allocated,
                    /*inout*/  int *target_part_ids,
                      /*out*/  int *target_part_ids_allocated,
                    /*inout*/  int command_code,  // e.g., MIGRATE,COPY
		       /*in*/  int update_ghost,  // e.g., YES,NO
		       /*in*/  int message_tag,
                               int *err);

// The implementation can post blocking receives or wait for non-
// blocking receives previously posted.  Targets are correct, because 
// there may be multiple parts on a processor and the application does 
// not need to know sources.  The message_tag ties 
// a send and receive pair together.

Vitus