X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a6b23c846948f7f89277f75e7c42f3942b31b8d3..f62c1bb030ea67ea9b49e0a49fbeeaf1198a2e03:/src/smpi/smpi_pmpi.c diff --git a/src/smpi/smpi_pmpi.c b/src/smpi/smpi_pmpi.c index 7a8e852c5f..09bb17c9a7 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,41 +20,41 @@ void TRACE_smpi_set_category(const char *category) //begin bench after changing process's category smpi_bench_begin(); } -#endif /* PMPI User level calls */ 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); - instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); - extra->type = TRACING_INIT; - TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra); - TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif - smpi_bench_begin(); + // PMPI_Init is call only one time by only by SMPI process + int already_init; + MPI_Initialized(&already_init); + if(!(already_init)){ + smpi_process_init(argc, argv); + smpi_process_mark_as_initialized(); + int rank = smpi_process_index(); + TRACE_smpi_init(rank); + TRACE_smpi_computing_init(rank); + instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); + extra->type = TRACING_INIT; + TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra); + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); + smpi_bench_begin(); + } return MPI_SUCCESS; } 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 +74,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(); @@ -85,7 +84,7 @@ int PMPI_Get_library_version (char *version,int *len){ int PMPI_Init_thread(int *argc, char ***argv, int required, int *provided) { if (provided != NULL) { - *provided = MPI_THREAD_MULTIPLE; + *provided = MPI_THREAD_SINGLE; } return MPI_Init(argc, argv); } @@ -97,7 +96,7 @@ int PMPI_Query_thread(int *provided) if (provided == NULL) { retval = MPI_ERR_ARG; } else { - *provided = MPI_THREAD_MULTIPLE; + *provided = MPI_THREAD_SINGLE; retval = MPI_SUCCESS; } return retval; @@ -999,26 +998,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 +1052,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 +1105,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 +1156,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 +1210,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 +1260,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 +1313,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(); @@ -1379,9 +1382,8 @@ int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status) } else if (*request == MPI_REQUEST_NULL) { *flag= TRUE; smpi_empty_status(status); - retval = MPI_ERR_REQUEST; + retval = MPI_SUCCESS; } else { -#ifdef HAVE_TRACING int rank = request && (*request)->comm != MPI_COMM_NULL ? smpi_process_index() : -1; @@ -1389,11 +1391,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(); @@ -1486,10 +1487,9 @@ int PMPI_Wait(MPI_Request * request, MPI_Status * status) if (request == NULL) { retval = MPI_ERR_ARG; } else if (*request == MPI_REQUEST_NULL) { - retval = MPI_ERR_REQUEST; + retval = MPI_SUCCESS; } else { -#ifdef HAVE_TRACING int rank = request && (*request)->comm != MPI_COMM_NULL ? smpi_process_index() : -1; @@ -1501,12 +1501,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 +1514,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 +1526,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 +1548,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 +1569,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 +1577,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 +1603,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 +1629,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 +1677,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 +1710,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 +1750,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 +1807,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 +1864,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 +1914,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 +1968,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 +2016,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 +2064,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 +2123,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 +2162,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 +2197,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 +2232,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 +2280,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 +2366,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 +2375,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(); @@ -2387,9 +2410,9 @@ int PMPI_Get_processor_name(char *name, int *resultlen) { int retval = MPI_SUCCESS; - strncpy(name, SIMIX_host_get_name(SIMIX_host_self()), - strlen(SIMIX_host_get_name(SIMIX_host_self())) < MPI_MAX_PROCESSOR_NAME - 1 ? - strlen(SIMIX_host_get_name(SIMIX_host_self())) +1 : + strncpy(name, sg_host_get_name(SIMIX_host_self()), + strlen(sg_host_get_name(SIMIX_host_self())) < MPI_MAX_PROCESSOR_NAME - 1 ? + strlen(sg_host_get_name(SIMIX_host_self())) +1 : MPI_MAX_PROCESSOR_NAME - 1 ); *resultlen = strlen(name) > @@ -2591,7 +2614,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 +2708,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,7 +2795,11 @@ int PMPI_Win_fence( int assert, MPI_Win win){ if (win == MPI_WIN_NULL) { retval = MPI_ERR_WIN; } else { - retval = smpi_mpi_win_fence(assert, win); + int rank = smpi_process_index(); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL); + retval = smpi_mpi_win_fence(assert, win); + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); + } smpi_bench_begin(); return retval; @@ -2798,7 +2825,15 @@ int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, (!is_datatype_valid(target_datatype))) { retval = MPI_ERR_TYPE; } else { + 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); + retval = smpi_mpi_get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win); + + TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); } smpi_bench_begin(); return retval; @@ -2824,7 +2859,16 @@ int PMPI_Put( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, (!is_datatype_valid(target_datatype))) { retval = MPI_ERR_TYPE; } else { + 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)); + retval = smpi_mpi_put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win); + + TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); } smpi_bench_begin(); return retval; @@ -2853,13 +2897,94 @@ int PMPI_Accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_da } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; } else { + 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); + retval = smpi_mpi_accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, op, win); + + TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); + } + 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); if(!ptr) @@ -2953,6 +3078,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); } @@ -2973,20 +3106,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) { @@ -3058,41 +3218,168 @@ int PMPI_Type_free_keyval(int* keyval) { return smpi_type_keyval_free(keyval); } -/* The following calls are not yet implemented and will fail at runtime. */ -/* Once implemented, please move them above this notice. */ +int PMPI_Info_create( MPI_Info *info){ + if (info == NULL) + 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; +} -#define NOT_YET_IMPLEMENTED { \ - XBT_WARN("Not yet implemented : %s. Please contact the Simgrid team if support is needed", __FUNCTION__); \ - return MPI_SUCCESS; \ +int PMPI_Info_set( MPI_Info info, char *key, char *value){ + if (info == NULL || key == NULL || value == NULL) + return MPI_ERR_ARG; + + xbt_dict_set(info->info_dict, key, (void*)value, NULL); + return MPI_SUCCESS; +} + +int PMPI_Info_free( MPI_Info *info){ + if (info == NULL || *info==NULL) + return MPI_ERR_ARG; + (*info)->refcount--; + if((*info)->refcount==0){ + xbt_dict_free(&((*info)->info_dict)); + xbt_free(*info); } + *info=MPI_INFO_NULL; + return MPI_SUCCESS; +} +int PMPI_Info_get(MPI_Info info,char *key,int valuelen, char *value, int *flag){ + if (info == NULL || key == NULL || valuelen <0) + return MPI_ERR_ARG; + if (value == NULL) + return MPI_ERR_INFO_VALUE; + *flag=FALSE; + char* tmpvalue=(char*)xbt_dict_get_or_null(info->info_dict, key); + if(tmpvalue){ + memcpy(value,tmpvalue, (strlen(tmpvalue) + 1 < valuelen) ? + strlen(tmpvalue) + 1 : valuelen); + *flag=TRUE; + } + return MPI_SUCCESS; +} -MPI_Info PMPI_Info_f2c(MPI_Fint info){ - NOT_YET_IMPLEMENTED +int PMPI_Info_dup(MPI_Info info, MPI_Info *newinfo){ + if (info == NULL || newinfo==NULL) + return MPI_ERR_ARG; + *newinfo = xbt_new(s_smpi_mpi_info_t, 1); + (*newinfo)->info_dict= xbt_dict_new_homogeneous(NULL); + xbt_dict_cursor_t cursor = NULL; + int *key; + void* data; + xbt_dict_foreach(info->info_dict,cursor,key,data){ + xbt_dict_set((*newinfo)->info_dict, (char*)key, data, NULL); + } + return MPI_SUCCESS; } -MPI_Fint PMPI_Info_c2f(MPI_Info info){ - NOT_YET_IMPLEMENTED +int PMPI_Info_delete(MPI_Info info, char *key){ + xbt_ex_t e; + if (info == NULL || key==NULL) + return MPI_ERR_ARG; + TRY { + xbt_dict_remove(info->info_dict, key); + }CATCH(e){ + xbt_ex_free(e); + return MPI_ERR_INFO_NOKEY; + } + return MPI_SUCCESS; } -MPI_Errhandler PMPI_Errhandler_f2c(MPI_Fint errhandler){ - NOT_YET_IMPLEMENTED +int PMPI_Info_get_nkeys( MPI_Info info, int *nkeys){ + if (info == NULL || nkeys==NULL) + return MPI_ERR_ARG; + *nkeys=xbt_dict_size(info->info_dict); + return MPI_SUCCESS; } -MPI_Fint PMPI_Errhandler_c2f(MPI_Errhandler errhandler){ - NOT_YET_IMPLEMENTED +int PMPI_Info_get_nthkey( MPI_Info info, int n, char *key){ + if (info == NULL || key==NULL || n<0 || n> MPI_MAX_INFO_KEY) + return MPI_ERR_ARG; + + xbt_dict_cursor_t cursor = NULL; + char *keyn; + void* data; + int num=0; + xbt_dict_foreach(info->info_dict,cursor,keyn,data){ + if(num==n){ + strcpy(key,keyn); + return MPI_SUCCESS; + } + num++; + } + return MPI_ERR_ARG; +} + +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; + char* tmpvalue=(char*)xbt_dict_get_or_null(info->info_dict, key); + if(tmpvalue){ + *valuelen=strlen(tmpvalue); + *flag=TRUE; + } + return MPI_SUCCESS; +} + +int PMPI_Unpack(void* inbuf, int incount, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) { + if(incount<0 || outcount < 0 || inbuf==NULL || outbuf==NULL) + return MPI_ERR_ARG; + if(!is_datatype_valid(type)) + return MPI_ERR_TYPE; + if(comm==MPI_COMM_NULL) + return MPI_ERR_COMM; + return smpi_mpi_unpack(inbuf, incount, position, outbuf,outcount,type, comm); +} + +int PMPI_Pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) { + if(incount<0 || outcount < 0|| inbuf==NULL || outbuf==NULL) + return MPI_ERR_ARG; + if(!is_datatype_valid(type)) + return MPI_ERR_TYPE; + if(comm==MPI_COMM_NULL) + return MPI_ERR_COMM; + return smpi_mpi_pack(inbuf, incount, type, outbuf,outcount,position, comm); } int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) { + if(incount<0) + return MPI_ERR_ARG; + if(!is_datatype_valid(datatype)) + return MPI_ERR_TYPE; + if(comm==MPI_COMM_NULL) + return MPI_ERR_COMM; + + *size=incount*smpi_datatype_size(datatype); + + return MPI_SUCCESS; +} + + +/* The following calls are not yet implemented and will fail at runtime. */ +/* Once implemented, please move them above this notice. */ + +#define NOT_YET_IMPLEMENTED { \ + XBT_WARN("Not yet implemented : %s. Please contact the Simgrid team if support is needed", __FUNCTION__); \ + return MPI_SUCCESS; \ + } + +MPI_Errhandler PMPI_Errhandler_f2c(MPI_Fint errhandler){ NOT_YET_IMPLEMENTED } +MPI_Fint PMPI_Errhandler_c2f(MPI_Errhandler errhandler){ + NOT_YET_IMPLEMENTED +} int PMPI_Cart_map(MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank) { NOT_YET_IMPLEMENTED } - int PMPI_Graph_create(MPI_Comm comm_old, int nnodes, int* index, int* edges, int reorder, MPI_Comm* comm_graph) { NOT_YET_IMPLEMENTED } @@ -3174,9 +3461,6 @@ int PMPI_Pcontrol(const int level ) NOT_YET_IMPLEMENTED } -int PMPI_Unpack(void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) { - NOT_YET_IMPLEMENTED -} int PMPI_Intercomm_create(MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag, MPI_Comm* comm_out) { NOT_YET_IMPLEMENTED @@ -3222,9 +3506,7 @@ int PMPI_Test_cancelled(MPI_Status* status, int* flag) { NOT_YET_IMPLEMENTED } -int PMPI_Pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) { - NOT_YET_IMPLEMENTED -} + int PMPI_Pack_external_size(char *datarep, int incount, MPI_Datatype datatype, MPI_Aint *size){ NOT_YET_IMPLEMENTED @@ -3242,17 +3524,7 @@ int PMPI_Get_elements(MPI_Status* status, MPI_Datatype datatype, int* elements) NOT_YET_IMPLEMENTED } -int PMPI_Info_create( MPI_Info *info){ - NOT_YET_IMPLEMENTED -} -int PMPI_Info_set( MPI_Info info, char *key, char *value){ - NOT_YET_IMPLEMENTED -} - -int PMPI_Info_free( MPI_Info *info){ - NOT_YET_IMPLEMENTED -} int PMPI_Type_get_envelope( MPI_Datatype datatype, int *num_integers, int *num_addresses, int *num_datatypes, int *combiner){ @@ -3305,10 +3577,6 @@ int PMPI_Comm_get_info (MPI_Comm comm, MPI_Info* info){ NOT_YET_IMPLEMENTED } -int PMPI_Info_get(MPI_Info info,char *key,int valuelen, char *value, int *flag){ - NOT_YET_IMPLEMENTED -} - int PMPI_Comm_create_errhandler( MPI_Comm_errhandler_fn *function, MPI_Errhandler *errhandler){ NOT_YET_IMPLEMENTED } @@ -3329,26 +3597,6 @@ int PMPI_Comm_call_errhandler(MPI_Comm comm,int errorcode){ NOT_YET_IMPLEMENTED } -int PMPI_Info_dup(MPI_Info info, MPI_Info *newinfo){ - NOT_YET_IMPLEMENTED -} - -int PMPI_Info_delete(MPI_Info info, char *key){ - NOT_YET_IMPLEMENTED -} - -int PMPI_Info_get_nkeys( MPI_Info info, int *nkeys){ - NOT_YET_IMPLEMENTED -} - -int PMPI_Info_get_nthkey( MPI_Info info, int n, char *key){ - NOT_YET_IMPLEMENTED -} - -int PMPI_Info_get_valuelen( MPI_Info info, char *key, int *valuelen, int *flag){ - NOT_YET_IMPLEMENTED -} - int PMPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status){ NOT_YET_IMPLEMENTED } @@ -3415,22 +3663,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 } @@ -3438,7 +3674,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 -}