X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/bf18d3ac263fc4e64e2ebd97592b21f1cf58e659..1b0a81fe3d9fec2f6891c25490d346876026ed22:/src/smpi/smpi_pmpi.c diff --git a/src/smpi/smpi_pmpi.c b/src/smpi/smpi_pmpi.c index 0e3b7f204e..fae36905ad 100644 --- a/src/smpi/smpi_pmpi.c +++ b/src/smpi/smpi_pmpi.c @@ -1,5 +1,5 @@ -/* Copyright (c) 2007-2014. The SimGrid Team. +/* Copyright (c) 2007-2015. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -11,7 +11,6 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_pmpi, smpi, "Logging specific to SMPI (pmpi)"); -#ifdef HAVE_TRACING //this function need to be here because of the calls to smpi_bench void TRACE_smpi_set_category(const char *category) { @@ -21,7 +20,6 @@ void TRACE_smpi_set_category(const char *category) //begin bench after changing process's category smpi_bench_begin(); } -#endif /* PMPI User level calls */ @@ -29,7 +27,6 @@ int PMPI_Init(int *argc, char ***argv) { smpi_process_init(argc, argv); smpi_process_mark_as_initialized(); -#ifdef HAVE_TRACING int rank = smpi_process_index(); TRACE_smpi_init(rank); TRACE_smpi_computing_init(rank); @@ -37,7 +34,6 @@ int PMPI_Init(int *argc, char ***argv) extra->type = TRACING_INIT; TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra); TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif smpi_bench_begin(); return MPI_SUCCESS; } @@ -45,17 +41,15 @@ int PMPI_Init(int *argc, char ***argv) int PMPI_Finalize(void) { smpi_bench_end(); -#ifdef HAVE_TRACING int rank = smpi_process_index(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_FINALIZE; TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra); -#endif + smpi_process_finalize(); -#ifdef HAVE_TRACING + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); TRACE_smpi_finalize(smpi_process_index()); -#endif smpi_process_destroy(); return MPI_SUCCESS; } @@ -75,7 +69,7 @@ int PMPI_Get_version (int *version,int *subversion){ int PMPI_Get_library_version (char *version,int *len){ int retval = MPI_SUCCESS; smpi_bench_end(); - snprintf(version,MPI_MAX_LIBRARY_VERSION_STRING,"SMPI Version %d.%d. Copyright The Simgrid Team 2007-2014",SIMGRID_VERSION_MAJOR, + snprintf(version,MPI_MAX_LIBRARY_VERSION_STRING,"SMPI Version %d.%d. Copyright The Simgrid Team 2007-2015",SIMGRID_VERSION_MAJOR, SIMGRID_VERSION_MINOR); *len = strlen(version) > MPI_MAX_LIBRARY_VERSION_STRING ? MPI_MAX_LIBRARY_VERSION_STRING : strlen(version); smpi_bench_begin(); @@ -999,26 +993,26 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, retval = MPI_ERR_TAG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int src_traced = smpi_group_index(smpi_comm_group(comm), src); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_IRECV; - extra->send_size = count; extra->src = src_traced; extra->dst = rank; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); -#endif *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); (*request)->recv = 1; -#endif } smpi_bench_begin(); @@ -1053,27 +1047,26 @@ int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst, retval = MPI_ERR_TAG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int dst_traced = smpi_group_index(smpi_comm_group(comm), dst); - instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ISEND; - extra->send_size = count; extra->src = rank; extra->dst = dst_traced; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); TRACE_smpi_send(rank, rank, dst_traced, count*smpi_datatype_size(datatype)); -#endif *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); (*request)->send = 1; -#endif } smpi_bench_begin(); @@ -1107,26 +1100,26 @@ int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, retval = MPI_ERR_TAG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int dst_traced = smpi_group_index(smpi_comm_group(comm), dst); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ISSEND; - extra->send_size = count; extra->src = rank; extra->dst = dst_traced; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); TRACE_smpi_send(rank, rank, dst_traced, count*smpi_datatype_size(datatype)); -#endif *request = smpi_mpi_issend(buf, count, datatype, dst, tag, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); (*request)->send = 1; -#endif } smpi_bench_begin(); @@ -1158,29 +1151,31 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, } else if(tag<0 && tag != MPI_ANY_TAG){ retval = MPI_ERR_TAG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int src_traced = smpi_group_index(smpi_comm_group(comm), src); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_RECV; - extra->send_size = count; extra->src = src_traced; extra->dst = rank; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); -#endif smpi_mpi_recv(buf, count, datatype, src, tag, comm, status); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE) if(status!=MPI_STATUS_IGNORE){ src_traced = smpi_group_index(smpi_comm_group(comm), status->MPI_SOURCE); - TRACE_smpi_recv(rank, src_traced, rank); + if (!TRACE_smpi_view_internals()) { + TRACE_smpi_recv(rank, src_traced, rank); + } } TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -1210,25 +1205,27 @@ int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, retval = MPI_ERR_TAG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int dst_traced = smpi_group_index(smpi_comm_group(comm), dst); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_SEND; - extra->send_size = count; extra->src = rank; extra->dst = dst_traced; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); - TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype)); -#endif + if (!TRACE_smpi_view_internals()) { + TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype)); + } smpi_mpi_send(buf, count, datatype, dst, tag, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -1258,24 +1255,24 @@ int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MP retval = MPI_ERR_TAG; } else { - #ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int dst_traced = smpi_group_index(smpi_comm_group(comm), dst); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_SSEND; - extra->send_size = count; extra->src = rank; extra->dst = dst_traced; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype)); - #endif smpi_mpi_ssend(buf, count, datatype, dst, tag, comm); retval = MPI_SUCCESS; - #ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); - #endif } smpi_bench_begin(); @@ -1311,33 +1308,34 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, retval = MPI_ERR_TAG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int dst_traced = smpi_group_index(smpi_comm_group(comm), dst); int src_traced = smpi_group_index(smpi_comm_group(comm), src); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_SENDRECV; - extra->send_size = sendcount; - extra->recv_size = recvcount; extra->src = src_traced; extra->dst = dst_traced; - extra->datatype1 = encode_datatype(sendtype); - extra->datatype2 = encode_datatype(recvtype); + int known=0; + extra->datatype1 = encode_datatype(sendtype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(sendtype); + extra->send_size = sendcount*dt_size_send; + extra->datatype2 = encode_datatype(recvtype, &known); + int dt_size_recv = 1; + if(!known) + dt_size_recv = smpi_datatype_size(recvtype); + extra->recv_size = recvcount*dt_size_recv; TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra); TRACE_smpi_send(rank, rank, dst_traced,sendcount*smpi_datatype_size(sendtype)); -#endif - smpi_mpi_sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf, recvcount, recvtype, src, recvtag, comm, status); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__); TRACE_smpi_recv(rank, src_traced, rank); -#endif - } smpi_bench_begin(); @@ -1381,7 +1379,6 @@ int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status) smpi_empty_status(status); retval = MPI_SUCCESS; } else { -#ifdef HAVE_TRACING int rank = request && (*request)->comm != MPI_COMM_NULL ? smpi_process_index() : -1; @@ -1389,11 +1386,10 @@ int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status) instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_TEST; TRACE_smpi_testing_in(rank, extra); -#endif + *flag = smpi_mpi_test(request, status); -#ifdef HAVE_TRACING + TRACE_smpi_testing_out(rank); -#endif retval = MPI_SUCCESS; } smpi_bench_begin(); @@ -1489,7 +1485,6 @@ int PMPI_Wait(MPI_Request * request, MPI_Status * status) retval = MPI_SUCCESS; } else { -#ifdef HAVE_TRACING int rank = request && (*request)->comm != MPI_COMM_NULL ? smpi_process_index() : -1; @@ -1501,12 +1496,10 @@ int PMPI_Wait(MPI_Request * request, MPI_Status * status) instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_WAIT; TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra); -#endif smpi_mpi_wait(request, status); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE) TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__); if (is_wait_for_receive) { @@ -1516,8 +1509,6 @@ int PMPI_Wait(MPI_Request * request, MPI_Status * status) src_traced; TRACE_smpi_recv(rank, src_traced, dst_traced); } -#endif - } smpi_bench_begin(); @@ -1530,7 +1521,6 @@ int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * sta return MPI_ERR_ARG; smpi_bench_end(); -#ifdef HAVE_TRACING //save requests information for tracing int i; int *srcs = xbt_new0(int, count); @@ -1553,9 +1543,8 @@ int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * sta extra->send_size=count; TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra); -#endif *index = smpi_mpi_waitany(count, requests, status); -#ifdef HAVE_TRACING + if(*index!=MPI_UNDEFINED){ int src_traced = srcs[*index]; //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE) @@ -1575,7 +1564,6 @@ int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * sta xbt_free(comms); } -#endif smpi_bench_begin(); return MPI_SUCCESS; } @@ -1584,7 +1572,6 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[]) { smpi_bench_end(); -#ifdef HAVE_TRACING //save information from requests int i; int *srcs = xbt_new0(int, count); @@ -1611,9 +1598,9 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[]) extra->type = TRACING_WAITALL; extra->send_size=count; TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra); -#endif + int retval = smpi_mpi_waitall(count, requests, status); -#ifdef HAVE_TRACING + for (i = 0; i < count; i++) { if(valid[i]){ //int src_traced = srcs[*index]; @@ -1637,7 +1624,6 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[]) xbt_free(valid); xbt_free(comms); -#endif smpi_bench_begin(); return retval; } @@ -1686,23 +1672,24 @@ int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm c } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_ARG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int root_traced = smpi_group_index(smpi_comm_group(comm), root); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_BCAST; - extra->send_size = count; extra->root = root_traced; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra); -#endif mpi_coll_bcast_fun(buf, count, datatype, root, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING - TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); -#endif + + TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); } smpi_bench_begin(); @@ -1718,17 +1705,15 @@ int PMPI_Barrier(MPI_Comm comm) if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_BARRIER; TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra); -#endif - mpi_coll_barrier_fun(comm); - retval = MPI_SUCCESS; -#ifdef HAVE_TRACING + + mpi_coll_barrier_fun(comm); + retval = MPI_SUCCESS; + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -1760,27 +1745,31 @@ int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype, sendtmpcount=0; sendtmptype=recvtype; } -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int root_traced = smpi_group_index(smpi_comm_group(comm), root); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_GATHER; - extra->send_size = sendtmpcount; - extra->recv_size = recvcount; extra->root = root_traced; - extra->datatype1 = encode_datatype(sendtmptype); - extra->datatype2 = encode_datatype(recvtype); + int known=0; + extra->datatype1 = encode_datatype(sendtmptype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(sendtmptype); + extra->send_size = sendtmpcount*dt_size_send; + extra->datatype2 = encode_datatype(recvtype, &known); + int dt_size_recv = 1; + if((smpi_comm_rank(comm)==root) && !known) + dt_size_recv = smpi_datatype_size(recvtype); + extra->recv_size = recvcount*dt_size_recv; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra); -#endif - mpi_coll_gather_fun(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, + + mpi_coll_gather_fun(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, root, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -1813,30 +1802,35 @@ int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, sendtmptype=recvtype; } -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int root_traced = smpi_group_index(smpi_comm_group(comm), root); int i=0; int size = smpi_comm_size(comm); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_GATHERV; - extra->send_size = sendtmpcount; - extra->recvcounts= xbt_malloc(size*sizeof(int)); - for(i=0; i< size; i++)//copy data to avoid bad free - extra->recvcounts[i] = recvcounts[i]; extra->num_processes = size; extra->root = root_traced; - extra->datatype1 = encode_datatype(sendtmptype); - extra->datatype2 = encode_datatype(recvtype); - + int known=0; + extra->datatype1 = encode_datatype(sendtmptype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(sendtype); + extra->send_size = sendtmpcount*dt_size_send; + extra->datatype2 = encode_datatype(recvtype, &known); + int dt_size_recv = 1; + if(!known) + dt_size_recv = smpi_datatype_size(recvtype); + if((smpi_comm_rank(comm)==root)){ + extra->recvcounts= xbt_malloc(size*sizeof(int)); + for(i=0; i< size; i++)//copy data to avoid bad free + extra->recvcounts[i] = recvcounts[i]*dt_size_recv; + } TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra); -#endif - smpi_mpi_gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts, + + smpi_mpi_gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts, displs, recvtype, root, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -1865,24 +1859,27 @@ int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype, sendcount=recvcount; sendtype=recvtype; } -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ALLGATHER; - extra->send_size = sendcount; - extra->recv_size = recvcount; - extra->datatype1 = encode_datatype(sendtype); - extra->datatype2 = encode_datatype(recvtype); + int known=0; + extra->datatype1 = encode_datatype(sendtype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(sendtype); + extra->send_size = sendcount*dt_size_send; + extra->datatype2 = encode_datatype(recvtype, &known); + int dt_size_recv = 1; + if(!known) + dt_size_recv = smpi_datatype_size(recvtype); + extra->recv_size = recvcount*dt_size_recv; TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra); -#endif - mpi_coll_allgather_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, + + mpi_coll_allgather_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm); retval = MPI_SUCCESS; - -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); return retval; @@ -1912,28 +1909,32 @@ int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, sendcount=recvcounts[smpi_comm_rank(comm)]; sendtype=recvtype; } -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int i=0; int size = smpi_comm_size(comm); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ALLGATHERV; - extra->send_size = sendcount; + extra->num_processes = size; + int known=0; + extra->datatype1 = encode_datatype(sendtype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(sendtype); + extra->send_size = sendcount*dt_size_send; + extra->datatype2 = encode_datatype(recvtype, &known); + int dt_size_recv = 1; + if(!known) + dt_size_recv = smpi_datatype_size(recvtype); extra->recvcounts= xbt_malloc(size*sizeof(int)); for(i=0; i< size; i++)//copy data to avoid bad free - extra->recvcounts[i] = recvcounts[i]; - extra->num_processes = size; - extra->datatype1 = encode_datatype(sendtype); - extra->datatype2 = encode_datatype(recvtype); + extra->recvcounts[i] = recvcounts[i]*dt_size_recv; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif + mpi_coll_allgatherv_fun(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -1962,25 +1963,28 @@ int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype, recvtype=sendtype; recvcount=sendcount; } -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int root_traced = smpi_group_index(smpi_comm_group(comm), root); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_SCATTER; - extra->send_size = sendcount; - extra->recv_size= recvcount; extra->root = root_traced; - extra->datatype1 = encode_datatype(sendtype); - extra->datatype2 = encode_datatype(recvtype); - + int known=0; + extra->datatype1 = encode_datatype(sendtype, &known); + int dt_size_send = 1; + if((smpi_comm_rank(comm)==root) && !known) + dt_size_send = smpi_datatype_size(sendtype); + extra->send_size = sendcount*dt_size_send; + extra->datatype2 = encode_datatype(recvtype, &known); + int dt_size_recv = 1; + if(!known) + dt_size_recv = smpi_datatype_size(recvtype); + extra->recv_size = recvcount*dt_size_recv; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra); -#endif - mpi_coll_scatter_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, + + mpi_coll_scatter_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2007,31 +2011,36 @@ int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs, recvtype=sendtype; recvcount=sendcounts[smpi_comm_rank(comm)]; } -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int root_traced = smpi_group_index(smpi_comm_group(comm), root); int i=0; int size = smpi_comm_size(comm); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_SCATTERV; - extra->recv_size = recvcount; - extra->sendcounts= xbt_malloc(size*sizeof(int)); - for(i=0; i< size; i++)//copy data to avoid bad free - extra->sendcounts[i] = sendcounts[i]; extra->num_processes = size; extra->root = root_traced; - extra->datatype1 = encode_datatype(sendtype); - extra->datatype2 = encode_datatype(recvtype); - + int known=0; + extra->datatype1 = encode_datatype(sendtype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(sendtype); + if((smpi_comm_rank(comm)==root)){ + extra->sendcounts= xbt_malloc(size*sizeof(int)); + for(i=0; i< size; i++)//copy data to avoid bad free + extra->sendcounts[i] = sendcounts[i]*dt_size_send; + } + extra->datatype2 = encode_datatype(recvtype, &known); + int dt_size_recv = 1; + if(!known) + dt_size_recv = smpi_datatype_size(recvtype); + extra->recv_size = recvcount*dt_size_recv; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra); -#endif smpi_mpi_scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm); + retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2050,23 +2059,24 @@ int PMPI_Reduce(void *sendbuf, void *recvbuf, int count, } else if (!is_datatype_valid(datatype) || op == MPI_OP_NULL) { retval = MPI_ERR_ARG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int root_traced = smpi_group_index(smpi_comm_group(comm), root); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_REDUCE; - extra->send_size = count; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; extra->root = root_traced; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra); -#endif - mpi_coll_reduce_fun(sendbuf, recvbuf, count, datatype, op, root, comm); + + mpi_coll_reduce_fun(sendbuf, recvbuf, count, datatype, op, root, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2108,25 +2118,25 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count, sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype)); smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype); } -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ALLREDUCE; - extra->send_size = count; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif - mpi_coll_allreduce_fun(sendtmpbuf, recvbuf, count, datatype, op, comm); - if( sendbuf == MPI_IN_PLACE ) { + mpi_coll_allreduce_fun(sendtmpbuf, recvbuf, count, datatype, op, comm); + + if( sendbuf == MPI_IN_PLACE ) xbt_free(sendtmpbuf); - } retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2147,20 +2157,22 @@ int PMPI_Scan(void *sendbuf, void *recvbuf, int count, } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_SCAN; - extra->send_size = count; - extra->datatype1 = encode_datatype(datatype); + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif - smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm); - retval = MPI_SUCCESS; -#ifdef HAVE_TRACING + + smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm); + + retval = MPI_SUCCESS; TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2180,20 +2192,20 @@ int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_EXSCAN; - extra->send_size = count; - extra->datatype1 = encode_datatype(datatype); - + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); + extra->send_size = count*dt_size_send; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif - smpi_mpi_exscan(sendbuf, recvbuf, count, datatype, op, comm); + + smpi_mpi_exscan(sendbuf, recvbuf, count, datatype, op, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2215,32 +2227,31 @@ int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, } else if (recvcounts == NULL) { retval = MPI_ERR_ARG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int i=0; int size = smpi_comm_size(comm); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_REDUCE_SCATTER; + extra->num_processes = size; + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); extra->send_size = 0; extra->recvcounts= xbt_malloc(size*sizeof(int)); for(i=0; i< size; i++)//copy data to avoid bad free - extra->recvcounts[i] = recvcounts[i]; - extra->num_processes = size; - extra->datatype1 = encode_datatype(datatype); - + extra->recvcounts[i] = recvcounts[i]*dt_size_send; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif - void* sendtmpbuf=sendbuf; - if(sendbuf==MPI_IN_PLACE){ + + void* sendtmpbuf=sendbuf; + if(sendbuf==MPI_IN_PLACE) sendtmpbuf=recvbuf; - } mpi_coll_reduce_scatter_fun(sendtmpbuf, recvbuf, recvcounts, datatype, op, comm); retval = MPI_SUCCESS; -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2264,28 +2275,30 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount, } else { int count=smpi_comm_size(comm); -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_REDUCE_SCATTER; + extra->num_processes = count; + int known=0; + extra->datatype1 = encode_datatype(datatype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(datatype); extra->send_size = 0; extra->recvcounts= xbt_malloc(count*sizeof(int)); for(i=0; i< count; i++)//copy data to avoid bad free - extra->recvcounts[i] = recvcount; - extra->num_processes = count; - extra->datatype1 = encode_datatype(datatype); + extra->recvcounts[i] = recvcount*dt_size_send; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif - int* recvcounts=(int*)xbt_malloc(count); + + int* recvcounts=(int*)xbt_malloc(count); for (i=0; itype = TRACING_ALLTOALL; - extra->send_size = sendcount; - extra->recv_size = recvcount; - extra->datatype1 = encode_datatype(sendtype); - extra->datatype2 = encode_datatype(recvtype); - + int known=0; + extra->datatype1 = encode_datatype(sendtype, &known); + if(!known) + extra->send_size = sendcount*smpi_datatype_size(sendtype); + else + extra->send_size = sendcount; + extra->datatype2 = encode_datatype(recvtype, &known); + if(!known) + extra->recv_size = recvcount*smpi_datatype_size(recvtype); + else + extra->recv_size = recvcount; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif - retval = mpi_coll_alltoall_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm); -#ifdef HAVE_TRACING + + retval = mpi_coll_alltoall_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm); + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2344,7 +2361,6 @@ int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps, || recvdisps == NULL) { retval = MPI_ERR_ARG; } else { -#ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; int i=0; int size = smpi_comm_size(comm); @@ -2354,28 +2370,30 @@ int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps, extra->recv_size = 0; extra->recvcounts= xbt_malloc(size*sizeof(int)); extra->sendcounts= xbt_malloc(size*sizeof(int)); - + int known=0; + extra->datatype1 = encode_datatype(sendtype, &known); + int dt_size_send = 1; + if(!known) + dt_size_send = smpi_datatype_size(sendtype); + int dt_size_recv = 1; + extra->datatype2 = encode_datatype(recvtype, &known); + if(!known) + dt_size_recv = smpi_datatype_size(recvtype); for(i=0; i< size; i++){//copy data to avoid bad free - extra->send_size += sendcounts[i]; - extra->recv_size += recvcounts[i]; + extra->send_size += sendcounts[i]*dt_size_send; + extra->recv_size += recvcounts[i]*dt_size_recv; - extra->sendcounts[i] = sendcounts[i]; - extra->recvcounts[i] = recvcounts[i]; + extra->sendcounts[i] = sendcounts[i]*dt_size_send; + extra->recvcounts[i] = recvcounts[i]*dt_size_recv; } extra->num_processes = size; - - extra->datatype1 = encode_datatype(sendtype); - extra->datatype2 = encode_datatype(recvtype); - TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif - retval = + + retval = mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, sendtype, recvbuf, recvcounts, recvdisps, recvtype, comm); -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2591,7 +2609,7 @@ int PMPI_Cart_create(MPI_Comm comm_old, int ndims, int* dims, int* periodic, int if (comm_old == MPI_COMM_NULL){ retval = MPI_ERR_COMM; } else if (ndims < 0 || - (ndims > 0 && (dims == NULL || + (ndims > 0 && (dims == NULL || periodic == NULL)) || comm_cart == NULL) { retval = MPI_ERR_ARG; @@ -2685,7 +2703,7 @@ int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, int blocks[3] = { 1, 1, 1 }; MPI_Aint disps[3] = { lb, 0, lb+extent }; MPI_Datatype types[3] = { MPI_LB, oldtype, MPI_UB }; - + s_smpi_mpi_struct_t* subtype = smpi_datatype_struct_create( blocks, disps, 3, @@ -2772,14 +2790,10 @@ int PMPI_Win_fence( int assert, MPI_Win win){ if (win == MPI_WIN_NULL) { retval = MPI_ERR_WIN; } else { -#ifdef HAVE_TRACING int rank = smpi_process_index(); TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL); -#endif retval = smpi_mpi_win_fence(assert, win); -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif } smpi_bench_begin(); @@ -2806,19 +2820,15 @@ int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, (!is_datatype_valid(target_datatype))) { retval = MPI_ERR_TYPE; } else { -#ifdef HAVE_TRACING int rank = smpi_process_index(); MPI_Group group; smpi_mpi_win_get_group(win, &group); int src_traced = smpi_group_index(group, target_rank); TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, NULL); -#endif retval = smpi_mpi_get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win); -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); -#endif } smpi_bench_begin(); return retval; @@ -2844,21 +2854,16 @@ int PMPI_Put( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, (!is_datatype_valid(target_datatype))) { retval = MPI_ERR_TYPE; } else { -#ifdef HAVE_TRACING int rank = smpi_process_index(); MPI_Group group; smpi_mpi_win_get_group(win, &group); int dst_traced = smpi_group_index(group, target_rank); TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, NULL); TRACE_smpi_send(rank, rank, dst_traced, origin_count*smpi_datatype_size(origin_datatype)); -#endif retval = smpi_mpi_put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win); -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); -#endif - } smpi_bench_begin(); return retval; @@ -2887,25 +2892,93 @@ int PMPI_Accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_da } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; } else { -#ifdef HAVE_TRACING int rank = smpi_process_index(); MPI_Group group; smpi_mpi_win_get_group(win, &group); int src_traced = smpi_group_index(group, target_rank); TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, NULL); -#endif retval = smpi_mpi_accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, op, win); -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); -#endif + } + smpi_bench_begin(); + return retval; +} + +int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){ + int retval = 0; + smpi_bench_end(); + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } else if (group==MPI_GROUP_NULL){ + retval = MPI_ERR_GROUP; + } + else { + int rank = smpi_process_index(); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL); + retval = smpi_mpi_win_post(group,assert,win); + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); } smpi_bench_begin(); return retval; } +int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){ + int retval = 0; + smpi_bench_end(); + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } else if (group==MPI_GROUP_NULL){ + retval = MPI_ERR_GROUP; + } + else { + int rank = smpi_process_index(); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL); + retval = smpi_mpi_win_start(group,assert,win); + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); + } + smpi_bench_begin(); + return retval; +} + + +int PMPI_Win_complete(MPI_Win win){ + int retval = 0; + smpi_bench_end(); + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } + else { + int rank = smpi_process_index(); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL); + + retval = smpi_mpi_win_complete(win); + + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); + } + smpi_bench_begin(); + return retval; +} + +int PMPI_Win_wait(MPI_Win win){ + int retval = 0; + smpi_bench_end(); + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } + else { + int rank = smpi_process_index(); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL); + + retval = smpi_mpi_win_wait(win); + + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); + } + smpi_bench_begin(); + return retval; +} int PMPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr){ void *ptr = xbt_malloc(size); @@ -3000,6 +3073,14 @@ MPI_Fint PMPI_Comm_c2f(MPI_Comm comm){ return smpi_comm_c2f(comm); } +MPI_Info PMPI_Info_f2c(MPI_Fint info){ + return smpi_info_f2c(info); +} + +MPI_Fint PMPI_Info_c2f(MPI_Info info){ + return smpi_info_c2f(info); +} + int PMPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) { return smpi_comm_keyval_create(copy_fn, delete_fn, keyval, extra_state); } @@ -3020,20 +3101,47 @@ int PMPI_Attr_delete(MPI_Comm comm, int keyval) { } int PMPI_Attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag) { + static int one = 1; + static int zero = 0; + static int tag_ub = 1000000; + static int last_used_code = MPI_ERR_LASTCODE; + if (comm==MPI_COMM_NULL){ - *flag=0; + *flag = 0; return MPI_ERR_COMM; - } else if(keyval == MPI_TAG_UB||keyval == MPI_HOST||keyval == MPI_IO - ||keyval == MPI_WTIME_IS_GLOBAL||keyval == MPI_APPNUM - ||keyval == MPI_UNIVERSE_SIZE||keyval == MPI_LASTUSEDCODE){ + } + + switch (keyval) { + case MPI_HOST: + case MPI_IO: + case MPI_APPNUM: + *flag = 1; + *(int**)attr_value = &zero; + return MPI_SUCCESS; + + case MPI_UNIVERSE_SIZE: + *flag = 1; + *(int**)attr_value = &smpi_universe_size; + return MPI_SUCCESS; + + case MPI_LASTUSEDCODE: + *flag = 1; + *(int**)attr_value = &last_used_code; + return MPI_SUCCESS; + + case MPI_TAG_UB: *flag=1; - //FIXME : not ideal and leaky, but should not be called too much - int* res = xbt_new(int, 1); - *res=keyval; - *(int**)attr_value=res; + *(int**)attr_value = &tag_ub; + return MPI_SUCCESS; + + case MPI_WTIME_IS_GLOBAL: + *flag = 1; + *(int**)attr_value = &one; return MPI_SUCCESS; - } else - return smpi_comm_attr_get(comm, keyval, attr_value, flag); + + default: + return smpi_comm_attr_get(comm, keyval, attr_value, flag); + } } int PMPI_Attr_put(MPI_Comm comm, int keyval, void* attr_value) { @@ -3110,6 +3218,7 @@ int PMPI_Info_create( MPI_Info *info){ return MPI_ERR_ARG; *info = xbt_new(s_smpi_mpi_info_t, 1); (*info)->info_dict= xbt_dict_new_homogeneous(NULL); + (*info)->refcount=1; return MPI_SUCCESS; } @@ -3124,8 +3233,11 @@ int PMPI_Info_set( MPI_Info info, char *key, char *value){ int PMPI_Info_free( MPI_Info *info){ if (info == NULL || *info==NULL) return MPI_ERR_ARG; - xbt_dict_free(&((*info)->info_dict)); - xbt_free(*info); + (*info)->refcount--; + if((*info)->refcount==0){ + xbt_dict_free(&((*info)->info_dict)); + xbt_free(*info); + } *info=MPI_INFO_NULL; return MPI_SUCCESS; } @@ -3135,10 +3247,10 @@ int PMPI_Info_get(MPI_Info info,char *key,int valuelen, char *value, int *flag){ return MPI_ERR_ARG; if (value == NULL) return MPI_ERR_INFO_VALUE; - *flag=FALSE; + *flag=FALSE; char* tmpvalue=(char*)xbt_dict_get_or_null(info->info_dict, key); if(tmpvalue){ - memcpy(value,tmpvalue, (strlen(tmpvalue) + 1 < valuelen) ? + memcpy(value,tmpvalue, (strlen(tmpvalue) + 1 < valuelen) ? strlen(tmpvalue) + 1 : valuelen); *flag=TRUE; } @@ -3189,7 +3301,7 @@ int PMPI_Info_get_nthkey( MPI_Info info, int n, char *key){ int num=0; xbt_dict_foreach(info->info_dict,cursor,keyn,data){ if(num==n){ - memcpy(key,keyn, strlen(keyn)); + strcpy(key,keyn); return MPI_SUCCESS; } num++; @@ -3200,7 +3312,7 @@ int PMPI_Info_get_nthkey( MPI_Info info, int n, char *key){ int PMPI_Info_get_valuelen( MPI_Info info, char *key, int *valuelen, int *flag){ if (info == NULL || key == NULL || valuelen <0) return MPI_ERR_ARG; - *flag=FALSE; + *flag=FALSE; char* tmpvalue=(char*)xbt_dict_get_or_null(info->info_dict, key); if(tmpvalue){ *valuelen=strlen(tmpvalue); @@ -3236,9 +3348,9 @@ int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) return MPI_ERR_TYPE; if(comm==MPI_COMM_NULL) return MPI_ERR_COMM; - + *size=incount*smpi_datatype_size(datatype); - + return MPI_SUCCESS; } @@ -3251,15 +3363,6 @@ int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) return MPI_SUCCESS; \ } - -MPI_Info PMPI_Info_f2c(MPI_Fint info){ - NOT_YET_IMPLEMENTED -} - -MPI_Fint PMPI_Info_c2f(MPI_Info info){ - NOT_YET_IMPLEMENTED -} - MPI_Errhandler PMPI_Errhandler_f2c(MPI_Fint errhandler){ NOT_YET_IMPLEMENTED } @@ -3555,22 +3658,10 @@ int PMPI_Comm_get_parent( MPI_Comm *parent){ NOT_YET_IMPLEMENTED } -int PMPI_Win_complete(MPI_Win win){ - NOT_YET_IMPLEMENTED -} - int PMPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win) { NOT_YET_IMPLEMENTED } -int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){ - NOT_YET_IMPLEMENTED -} - -int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){ - NOT_YET_IMPLEMENTED -} - int PMPI_Win_test(MPI_Win win, int *flag){ NOT_YET_IMPLEMENTED } @@ -3578,7 +3669,3 @@ int PMPI_Win_test(MPI_Win win, int *flag){ int PMPI_Win_unlock(int rank, MPI_Win win){ NOT_YET_IMPLEMENTED } - -int PMPI_Win_wait(MPI_Win win){ - NOT_YET_IMPLEMENTED -}