itaps-parallel Assignments for parallel interface, due before 2/5 phone conf
Onkar Sahni
osahni at scorec.rpi.edu
Tue Feb 5 13:49:32 CST 2008
>
> 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.
I do not know if two calls will be sufficient for non-blocking send and
recv., I still think we need equivalent of finishSendRecv (like
MPI_Waitall). And don't we need a call for setup of communications
upfront, if we do then we can pass message tag, update_ghost,
command_code in there and store them in itapsSendRecvTag and reuse this
tag in other calls (send, recv etc.). For 'target' in recv.,
entity_handles can easily provide this information and I am not sure
that source will not be useful or needed for all applications. In any
case, syntax and name (where to use 'Par') might change on which calls
(or model) we decide/agree on.
Thanks,
Onkar
>
> 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
>
>
>
>
More information about the itaps-parallel
mailing list