X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9f8d811451ee11bbb7dcfa82a30486f3aec5e6ca..9c5bf90e5d5afd43baf314cb79b03c20a012d5cb:/src/smpi/smpi_replay.c diff --git a/src/smpi/smpi_replay.c b/src/smpi/smpi_replay.c index a8ffb170c1..59c16014f9 100644 --- a/src/smpi/smpi_replay.c +++ b/src/smpi/smpi_replay.c @@ -9,11 +9,13 @@ #include #include +#define KEY_SIZE (sizeof(int) * 2 + 1) + XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_replay,smpi,"Trace Replay with SMPI"); int communicator_size = 0; static int active_processes = 0; -xbt_dynar_t *reqq = NULL; +xbt_dict_t reqq = NULL; MPI_Datatype MPI_DEFAULT_TYPE; MPI_Datatype MPI_CURRENT_TYPE; @@ -31,6 +33,26 @@ static void log_timed_action (const char *const *action, double clock){ } } + +static xbt_dynar_t get_reqq_self(){ + char * key; + + asprintf(&key, "%d", smpi_process_index()); + xbt_dynar_t dynar_mpi_request = (xbt_dynar_t) xbt_dict_get(reqq, key); + free(key); + + return dynar_mpi_request; +} + +static void set_reqq_self(xbt_dynar_t mpi_request){ + char * key; + + asprintf(&key, "%d", smpi_process_index()); + xbt_dict_set(reqq, key, mpi_request, free); + free(key); +} + + //allocate a single buffer for all sends, growing it if needed void* smpi_get_tmp_sendbuffer(int size){ if (!smpi_process_get_replaying()) @@ -103,11 +125,12 @@ static MPI_Datatype decode_datatype(const char *const action) } -const char* encode_datatype(MPI_Datatype datatype) +const char* encode_datatype(MPI_Datatype datatype, int* known) { //default type for output is set to MPI_BYTE // MPI_DEFAULT_TYPE is not set for output, use directly MPI_BYTE + if(known)*known=1; if (datatype==MPI_BYTE){ return ""; } @@ -123,17 +146,29 @@ const char* encode_datatype(MPI_Datatype datatype) return "4"; if(datatype==MPI_FLOAT) return "5"; - + //tell that the datatype is not handled by replay, and that its size should be measured and replayed as size*MPI_BYTE + if(known)*known=0; // default - not implemented. // do not warn here as we pass in this function even for other trace formats return "-1"; } +#define CHECK_ACTION_PARAMS(action, mandatory, optional) {\ + int i=0;\ + while(action[i]!=NULL)\ + i++;\ + if(itype=TRACING_COMPUTING; extra->comp_size=flops; TRACE_smpi_computing_in(rank, extra); -#endif + smpi_execute_flops(flops); -#ifdef HAVE_TRACING - TRACE_smpi_computing_out(rank); -#endif + TRACE_smpi_computing_out(rank); log_timed_action (action, clock); } static void action_send(const char *const *action) { + CHECK_ACTION_PARAMS(action, 2, 1); int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); @@ -208,7 +249,6 @@ static void action_send(const char *const *action) MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; } -#ifdef HAVE_TRACING int rank = smpi_process_index(); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); @@ -217,23 +257,20 @@ static void action_send(const char *const *action) extra->send_size = size; extra->src = rank; extra->dst = dst_traced; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE)); -#endif smpi_mpi_send(NULL, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD); log_timed_action (action, clock); - #ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); -#endif - } static void action_Isend(const char *const *action) { + CHECK_ACTION_PARAMS(action, 2, 1); int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); @@ -242,7 +279,6 @@ static void action_Isend(const char *const *action) if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; -#ifdef HAVE_TRACING int rank = smpi_process_index(); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); @@ -250,24 +286,22 @@ static void action_Isend(const char *const *action) extra->send_size = size; extra->src = rank; extra->dst = dst_traced; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE)); -#endif request = smpi_mpi_isend(NULL, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD); -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); request->send = 1; -#endif - xbt_dynar_push(reqq[smpi_process_index()],&request); + xbt_dynar_push(get_reqq_self(),&request); log_timed_action (action, clock); } static void action_recv(const char *const *action) { + CHECK_ACTION_PARAMS(action, 2, 1); int from = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); @@ -276,7 +310,6 @@ static void action_recv(const char *const *action) { if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; -#ifdef HAVE_TRACING int rank = smpi_process_index(); int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from); @@ -285,9 +318,8 @@ static void action_recv(const char *const *action) { extra->send_size = size; extra->src = src_traced; extra->dst = rank; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); -#endif //unknow size from the receiver pov if(size==-1){ @@ -297,16 +329,15 @@ static void action_recv(const char *const *action) { smpi_mpi_recv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status); -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); TRACE_smpi_recv(rank, src_traced, rank); -#endif log_timed_action (action, clock); } static void action_Irecv(const char *const *action) { + CHECK_ACTION_PARAMS(action, 2, 1); int from = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); @@ -315,7 +346,6 @@ static void action_Irecv(const char *const *action) if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; -#ifdef HAVE_TRACING int rank = smpi_process_index(); int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); @@ -323,9 +353,8 @@ static void action_Irecv(const char *const *action) extra->send_size = size; extra->src = src_traced; extra->dst = rank; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); -#endif MPI_Status status; //unknow size from the receiver pov if(size==-1){ @@ -335,53 +364,53 @@ static void action_Irecv(const char *const *action) request = smpi_mpi_irecv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD); -#ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); request->recv = 1; -#endif - xbt_dynar_push(reqq[smpi_process_index()],&request); + xbt_dynar_push(get_reqq_self(),&request); log_timed_action (action, clock); } static void action_test(const char *const *action){ + CHECK_ACTION_PARAMS(action, 0, 0); double clock = smpi_process_simulated_elapsed(); MPI_Request request; MPI_Status status; int flag = TRUE; - request = xbt_dynar_pop_as(reqq[smpi_process_index()],MPI_Request); - xbt_assert(request != NULL, "found null request in reqq"); - -#ifdef HAVE_TRACING - int rank = smpi_process_index(); - 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); - XBT_DEBUG("MPI_Test result: %d", flag); - /* push back request in dynar to be caught by a subsequent wait. if the test - * did succeed, the request is now NULL. - */ - xbt_dynar_push_as(reqq[smpi_process_index()],MPI_Request, request); - -#ifdef HAVE_TRACING - TRACE_smpi_testing_out(rank); -#endif - + request = xbt_dynar_pop_as(get_reqq_self(),MPI_Request); + //if request is null here, this may mean that a previous test has succeeded + //Different times in traced application and replayed version may lead to this + //In this case, ignore the extra calls. + if(request){ + int rank = smpi_process_index(); + instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); + extra->type=TRACING_TEST; + TRACE_smpi_testing_in(rank, extra); + + flag = smpi_mpi_test(&request, &status); + + XBT_DEBUG("MPI_Test result: %d", flag); + /* push back request in dynar to be caught by a subsequent wait. if the test + * did succeed, the request is now NULL. + */ + xbt_dynar_push_as(get_reqq_self(),MPI_Request, request); + + TRACE_smpi_testing_out(rank); + } log_timed_action (action, clock); } static void action_wait(const char *const *action){ + CHECK_ACTION_PARAMS(action, 0, 0); double clock = smpi_process_simulated_elapsed(); MPI_Request request; MPI_Status status; - xbt_assert(xbt_dynar_length(reqq[smpi_process_index()]), + xbt_assert(xbt_dynar_length(get_reqq_self()), "action wait not preceded by any irecv or isend: %s", xbt_str_join_array(action," ")); - request = xbt_dynar_pop_as(reqq[smpi_process_index()],MPI_Request); + request = xbt_dynar_pop_as(get_reqq_self(),MPI_Request); if (!request){ /* Assuming that the trace is well formed, this mean the comm might have @@ -390,7 +419,6 @@ static void action_wait(const char *const *action){ return; } -#ifdef HAVE_TRACING int rank = request->comm != MPI_COMM_NULL ? smpi_comm_rank(request->comm) : -1; @@ -402,24 +430,22 @@ static void action_wait(const char *const *action){ 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); -#ifdef HAVE_TRACING + TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__); - if (is_wait_for_receive) { + if (is_wait_for_receive) TRACE_smpi_recv(rank, src_traced, dst_traced); - } -#endif - log_timed_action (action, clock); } static void action_waitall(const char *const *action){ + CHECK_ACTION_PARAMS(action, 0, 0); double clock = smpi_process_simulated_elapsed(); int count_requests=0; unsigned int i=0; - count_requests=xbt_dynar_length(reqq[smpi_process_index()]); + count_requests=xbt_dynar_length(get_reqq_self()); if (count_requests>0) { MPI_Request requests[count_requests]; @@ -427,9 +453,8 @@ static void action_waitall(const char *const *action){ /* The reqq is an array of dynars. Its index corresponds to the rank. Thus each rank saves its own requests to the array request. */ - xbt_dynar_foreach(reqq[smpi_process_index()],i,requests[i]); + xbt_dynar_foreach(get_reqq_self(),i,requests[i]); - #ifdef HAVE_TRACING //save information from requests xbt_dynar_t srcs = xbt_dynar_new(sizeof(int), NULL); @@ -462,11 +487,9 @@ static void action_waitall(const char *const *action){ extra->type = TRACING_WAITALL; extra->send_size=count_requests; TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra); - #endif - smpi_mpi_waitall(count_requests, requests, status); + smpi_mpi_waitall(count_requests, requests, status); - #ifdef HAVE_TRACING for (i = 0; i < count_requests; i++) { int src_traced, dst_traced, is_wait_for_receive; xbt_dynar_get_cpy(srcs, i, &src_traced); @@ -481,34 +504,30 @@ static void action_waitall(const char *const *action){ xbt_dynar_free(&srcs); xbt_dynar_free(&dsts); xbt_dynar_free(&recvs); - #endif - int freedrank=smpi_process_index(); - xbt_dynar_free_container(&(reqq[freedrank])); - reqq[freedrank]=xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref); + //TODO xbt_dynar_free_container(get_reqq_self()); + set_reqq_self(xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref)); } log_timed_action (action, clock); } static void action_barrier(const char *const *action){ double clock = smpi_process_simulated_elapsed(); -#ifdef HAVE_TRACING int rank = smpi_process_index(); 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(MPI_COMM_WORLD); -#ifdef HAVE_TRACING - TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); log_timed_action (action, clock); } static void action_bcast(const char *const *action) { + CHECK_ACTION_PARAMS(action, 1, 2); double size = parse_double(action[2]); double clock = smpi_process_simulated_elapsed(); int root=0; @@ -525,7 +544,6 @@ static void action_bcast(const char *const *action) } } -#ifdef HAVE_TRACING int rank = smpi_process_index(); int root_traced = smpi_group_index(smpi_comm_group(MPI_COMM_WORLD), root); @@ -533,20 +551,19 @@ static void action_bcast(const char *const *action) extra->type = TRACING_BCAST; extra->send_size = size; extra->root = root_traced; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra); + void *sendbuf = smpi_get_tmp_sendbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE)); -#endif - void *sendbuf = smpi_get_tmp_sendbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE)); mpi_coll_bcast_fun(sendbuf, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD); -#ifdef HAVE_TRACING + TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); -#endif log_timed_action (action, clock); } static void action_reduce(const char *const *action) { + CHECK_ACTION_PARAMS(action, 2, 2); double comm_size = parse_double(action[2]); double comp_size = parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); @@ -562,29 +579,28 @@ static void action_reduce(const char *const *action) -#ifdef HAVE_TRACING int rank = smpi_process_index(); int root_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), root); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_REDUCE; extra->send_size = comm_size; extra->comp_size = comp_size; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); extra->root = root_traced; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra); -#endif - void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); - void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); + + void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); + void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); mpi_coll_reduce_fun(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, root, MPI_COMM_WORLD); smpi_execute_flops(comp_size); -#ifdef HAVE_TRACING + TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); -#endif log_timed_action (action, clock); } static void action_allReduce(const char *const *action) { + CHECK_ACTION_PARAMS(action, 2, 1); double comm_size = parse_double(action[2]); double comp_size = parse_double(action[3]); @@ -592,23 +608,20 @@ static void action_allReduce(const char *const *action) { else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; double clock = smpi_process_simulated_elapsed(); -#ifdef HAVE_TRACING int rank = smpi_process_index(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ALLREDUCE; extra->send_size = comm_size; extra->comp_size = comp_size; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); - + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif - void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); - void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); + + void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); + void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); mpi_coll_allreduce_fun(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD); smpi_execute_flops(comp_size); -#ifdef HAVE_TRACING + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif log_timed_action (action, clock); } @@ -630,25 +643,20 @@ static void action_allToAll(const char *const *action) { void *send = smpi_get_tmp_sendbuffer(send_size*comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); void *recv = smpi_get_tmp_recvbuffer(recv_size*comm_size* smpi_datatype_size(MPI_CURRENT_TYPE2)); -#ifdef HAVE_TRACING int rank = smpi_process_index(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ALLTOALL; extra->send_size = send_size; extra->recv_size = recv_size; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif mpi_coll_alltoall_fun(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, MPI_COMM_WORLD); -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif log_timed_action (action, clock); - } @@ -665,6 +673,7 @@ static void action_gather(const char *const *action) { 4) 0 is the send datatype id, see decode_datatype() 5) 0 is the recv datatype id, see decode_datatype() */ + CHECK_ACTION_PARAMS(action, 2, 3); double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); int send_size = parse_double(action[2]); @@ -679,33 +688,30 @@ static void action_gather(const char *const *action) { } void *send = smpi_get_tmp_sendbuffer(send_size* smpi_datatype_size(MPI_CURRENT_TYPE)); void *recv = NULL; - - int root=atoi(action[4]); + int root=0; + if(action[4]) + root=atoi(action[4]); int rank = smpi_comm_rank(MPI_COMM_WORLD); if(rank==root) recv = smpi_get_tmp_recvbuffer(recv_size*comm_size* smpi_datatype_size(MPI_CURRENT_TYPE2)); -#ifdef HAVE_TRACING instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_GATHER; extra->send_size = send_size; extra->recv_size = recv_size; extra->root = root; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra); -#endif + mpi_coll_gather_fun(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD); -#ifdef HAVE_TRACING TRACE_smpi_collective_out(smpi_process_index(), -1, __FUNCTION__); -#endif log_timed_action (action, clock); - } @@ -723,8 +729,10 @@ static void action_gatherv(const char *const *action) { 4) 0 is the send datatype id, see decode_datatype() 5) 0 is the recv datatype id, see decode_datatype() */ + double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); + CHECK_ACTION_PARAMS(action, comm_size+1, 2); int send_size = parse_double(action[2]); int *disps = xbt_new0(int, comm_size); int *recvcounts = xbt_new0(int, comm_size); @@ -752,7 +760,6 @@ static void action_gatherv(const char *const *action) { if(rank==root) recv = smpi_get_tmp_recvbuffer(recv_sum* smpi_datatype_size(MPI_CURRENT_TYPE2)); -#ifdef HAVE_TRACING instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_GATHERV; extra->send_size = send_size; @@ -761,19 +768,16 @@ static void action_gatherv(const char *const *action) { extra->recvcounts[i] = recvcounts[i]; extra->root = root; extra->num_processes = comm_size; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra); -#endif -smpi_mpi_gatherv(send, send_size, MPI_CURRENT_TYPE, + + smpi_mpi_gatherv(send, send_size, MPI_CURRENT_TYPE, recv, recvcounts, disps, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD); -#ifdef HAVE_TRACING TRACE_smpi_collective_out(smpi_process_index(), -1, __FUNCTION__); -#endif - log_timed_action (action, clock); xbt_free(recvcounts); xbt_free(disps); @@ -797,6 +801,7 @@ static void action_reducescatter(const char *const *action) { double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); + CHECK_ACTION_PARAMS(action, comm_size+1, 1); int comp_size = parse_double(action[2+comm_size]); int *recvcounts = xbt_new0(int, comm_size); int *disps = xbt_new0(int, comm_size); @@ -814,35 +819,80 @@ static void action_reducescatter(const char *const *action) { size+=recvcounts[i]; } -#ifdef HAVE_TRACING instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_REDUCE_SCATTER; extra->send_size = 0; extra->recvcounts= xbt_malloc(comm_size*sizeof(int)); for(i=0; i< comm_size; i++)//copy data to avoid bad free extra->recvcounts[i] = recvcounts[i]; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); extra->comp_size = comp_size; extra->num_processes = comm_size; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif + void *sendbuf = smpi_get_tmp_sendbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE)); - void *recvbuf = smpi_get_tmp_recvbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE)); + void *recvbuf = smpi_get_tmp_recvbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE)); mpi_coll_reduce_scatter_fun(sendbuf, recvbuf, recvcounts, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD); smpi_execute_flops(comp_size); -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif xbt_free(recvcounts); xbt_free(disps); log_timed_action (action, clock); } +static void action_allgather(const char *const *action) { + /* + The structure of the allgather action for the rank 0 (total 4 processes) + is the following: + 0 allGather 275427 275427 + + where: + 1) 275427 is the sendcount + 2) 275427 is the recvcount + 3) No more values mean that the datatype for sent and receive buffer + is the default one, see decode_datatype(). + + */ + + double clock = smpi_process_simulated_elapsed(); + + CHECK_ACTION_PARAMS(action, 2, 2); + int sendcount=atoi(action[2]); + int recvcount=atoi(action[3]); + + MPI_Datatype MPI_CURRENT_TYPE2; + + if(action[4]) { + MPI_CURRENT_TYPE = decode_datatype(action[3]); + MPI_CURRENT_TYPE2 = decode_datatype(action[4]); + } else { + MPI_CURRENT_TYPE = MPI_DEFAULT_TYPE; + MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE; + } + void *sendbuf = smpi_get_tmp_sendbuffer(sendcount* smpi_datatype_size(MPI_CURRENT_TYPE)); + void *recvbuf = smpi_get_tmp_recvbuffer(recvcount* smpi_datatype_size(MPI_CURRENT_TYPE2)); + + int rank = smpi_process_index(); + 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(MPI_CURRENT_TYPE, NULL); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); + extra->num_processes = smpi_comm_size(MPI_COMM_WORLD); + + TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); + + mpi_coll_allgather_fun(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcount, MPI_CURRENT_TYPE2, MPI_COMM_WORLD); + + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); + log_timed_action (action, clock); +} static void action_allgatherv(const char *const *action) { @@ -862,6 +912,7 @@ static void action_allgatherv(const char *const *action) { double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); + CHECK_ACTION_PARAMS(action, comm_size+1, 2); int i=0; int sendcount=atoi(action[2]); int *recvcounts = xbt_new0(int, comm_size); @@ -884,7 +935,6 @@ static void action_allgatherv(const char *const *action) { } void *recvbuf = smpi_get_tmp_recvbuffer(recv_sum* smpi_datatype_size(MPI_CURRENT_TYPE2)); -#ifdef HAVE_TRACING int rank = smpi_process_index(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ALLGATHERV; @@ -892,25 +942,20 @@ static void action_allgatherv(const char *const *action) { extra->recvcounts= xbt_malloc(comm_size*sizeof(int)); for(i=0; i< comm_size; i++)//copy data to avoid bad free extra->recvcounts[i] = recvcounts[i]; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); extra->num_processes = comm_size; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif mpi_coll_allgatherv_fun(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2, MPI_COMM_WORLD); -#ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif - log_timed_action (action, clock); xbt_free(recvcounts); xbt_free(disps); } - static void action_allToAllv(const char *const *action) { /* The structure of the allToAllV action for the rank 0 (total 4 processes) @@ -929,6 +974,7 @@ static void action_allToAllv(const char *const *action) { double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); + CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2); int send_buf_size=0,recv_buf_size=0,i=0; int *sendcounts = xbt_new0(int, comm_size); int *recvcounts = xbt_new0(int, comm_size); @@ -957,7 +1003,6 @@ static void action_allToAllv(const char *const *action) { } -#ifdef HAVE_TRACING int rank = smpi_process_index(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_ALLTOALLV; @@ -971,18 +1016,16 @@ static void action_allToAllv(const char *const *action) { extra->recv_size += recvcounts[i]; extra->recvcounts[i] = recvcounts[i]; } - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); -#endif + mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE, recvbuf, recvcounts, recvdisps, MPI_CURRENT_TYPE, MPI_COMM_WORLD); -#ifdef HAVE_TRACING - TRACE_smpi_collective_out(rank, -1, __FUNCTION__); -#endif + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); log_timed_action (action, clock); xbt_free(sendcounts); xbt_free(recvcounts); @@ -994,7 +1037,7 @@ void smpi_replay_init(int *argc, char***argv){ smpi_process_init(argc, argv); smpi_process_mark_as_initialized(); smpi_process_set_replaying(1); -#ifdef HAVE_TRACING + int rank = smpi_process_index(); TRACE_smpi_init(rank); TRACE_smpi_computing_init(rank); @@ -1002,10 +1045,8 @@ void smpi_replay_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 - if (!smpi_process_index()){ - _xbt_replay_action_init(); + if (!_xbt_replay_action_init()) { xbt_replay_action_register("init", action_init); xbt_replay_action_register("finalize", action_finalize); xbt_replay_action_register("comm_size", action_comm_size); @@ -1026,6 +1067,7 @@ void smpi_replay_init(int *argc, char***argv){ xbt_replay_action_register("allToAllV", action_allToAllv); xbt_replay_action_register("gather", action_gather); xbt_replay_action_register("gatherV", action_gatherv); + xbt_replay_action_register("allGather", action_allgather); xbt_replay_action_register("allGatherV", action_allgatherv); xbt_replay_action_register("reduceScatter", action_reducescatter); xbt_replay_action_register("compute", action_compute); @@ -1039,7 +1081,12 @@ void smpi_replay_init(int *argc, char***argv){ THROWF(unknown_error, 0, "%s is not a double", (*argv)[2]); XBT_VERB("Delayed start for instance - Sleeping for %f flops ",value ); smpi_execute_flops(value); + } else { + //UGLY done to force context switch to be sure that all MSG_processes begin initialization + XBT_DEBUG("Force context switch by smpi_execute_flops - Sleeping for 0.0 flops "); + smpi_execute_flops(0.0); } + xbt_replay_action_runner(*argc, *argv); } @@ -1047,14 +1094,14 @@ int smpi_replay_finalize(){ double sim_time= 1.; /* One active process will stop. Decrease the counter*/ XBT_DEBUG("There are %lu elements in reqq[*]", - xbt_dynar_length(reqq[smpi_process_index()])); - if (!xbt_dynar_is_empty(reqq[smpi_process_index()])){ - int count_requests=xbt_dynar_length(reqq[smpi_process_index()]); + xbt_dynar_length(get_reqq_self())); + if (!xbt_dynar_is_empty(get_reqq_self())){ + int count_requests=xbt_dynar_length(get_reqq_self()); MPI_Request requests[count_requests]; MPI_Status status[count_requests]; unsigned int i; - xbt_dynar_foreach(reqq[smpi_process_index()],i,requests[i]); + xbt_dynar_foreach(get_reqq_self(),i,requests[i]); smpi_mpi_waitall(count_requests, requests, status); active_processes--; } else { @@ -1068,29 +1115,28 @@ int smpi_replay_finalize(){ } - xbt_dynar_free_container(&(reqq[smpi_process_index()])); + //TODO xbt_dynar_free_container(get_reqq_self())); if(!active_processes){ XBT_INFO("Simulation time %f", sim_time); _xbt_replay_action_exit(); xbt_free(sendbuffer); xbt_free(recvbuffer); - xbt_free(reqq); + //xbt_free(reqq); + xbt_dict_free(&reqq); //not need, data have been freed ??? reqq = NULL; } -#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; }