X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/347996b4a10c4e8579080692afa60e0afb88b60a..510e081f7d3f45bf4a464ad3080f89d0a1e9b282:/src/smpi/smpi_replay.cpp diff --git a/src/smpi/smpi_replay.cpp b/src/smpi/smpi_replay.cpp index 4648703d05..b62e3ff56f 100644 --- a/src/smpi/smpi_replay.cpp +++ b/src/smpi/smpi_replay.cpp @@ -5,9 +5,10 @@ * under the terms of the license (GNU LGPL) which comes with this package. */ #include "private.h" -#include #include #include +#include +#include #define KEY_SIZE (sizeof(int) * 2 + 1) @@ -15,62 +16,50 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_replay,smpi,"Trace Replay with SMPI"); int communicator_size = 0; static int active_processes = 0; -xbt_dict_t reqq = NULL; +std::unordered_map*> reqq; MPI_Datatype MPI_DEFAULT_TYPE; MPI_Datatype MPI_CURRENT_TYPE; static int sendbuffer_size=0; -char* sendbuffer=NULL; +char* sendbuffer=nullptr; static int recvbuffer_size=0; -char* recvbuffer=NULL; +char* recvbuffer=nullptr; static void log_timed_action (const char *const *action, double clock){ if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){ char *name = xbt_str_join_array(action, " "); XBT_VERB("%s %f", name, smpi_process_simulated_elapsed()-clock); - free(name); + xbt_free(name); } } - -static xbt_dynar_t get_reqq_self(){ - char * key; - - int size = asprintf(&key, "%d", smpi_process_index()); - if(size==-1) - xbt_die("could not allocate memory for asprintf"); - xbt_dynar_t dynar_mpi_request = (xbt_dynar_t) xbt_dict_get(reqq, key); - free(key); - - return dynar_mpi_request; +static std::vector* get_reqq_self() +{ + return reqq.at(smpi_process_index()); } -static void set_reqq_self(xbt_dynar_t mpi_request){ - char * key; - - int size = asprintf(&key, "%d", smpi_process_index()); - if(size==-1) - xbt_die("could not allocate memory for asprintf"); - xbt_dict_set(reqq, key, mpi_request, free); - free(key); +static void set_reqq_self(std::vector *mpi_request) +{ + reqq.insert({smpi_process_index(), mpi_request}); } - //allocate a single buffer for all sends, growing it if needed -void* smpi_get_tmp_sendbuffer(int size){ +void* smpi_get_tmp_sendbuffer(int size) +{ if (!smpi_process_get_replaying()) - return xbt_malloc(size); + return xbt_malloc(size); if (sendbuffer_size(xbt_realloc(sendbuffer,size)); sendbuffer_size=size; } return sendbuffer; } + //allocate a single buffer for all recv void* smpi_get_tmp_recvbuffer(int size){ if (!smpi_process_get_replaying()) - return xbt_malloc(size); + return xbt_malloc(size); if (recvbuffer_size(xbt_realloc(recvbuffer,size)); recvbuffer_size=size; @@ -86,9 +75,8 @@ void smpi_free_tmp_buffer(void* buf){ /* Helper function */ static double parse_double(const char *string) { - double value; char *endptr; - value = strtod(string, &endptr); + double value = strtod(string, &endptr); if (*endptr != '\0') THROWF(unknown_error, 0, "%s is not a double", string); return value; @@ -96,10 +84,7 @@ static double parse_double(const char *string) static MPI_Datatype decode_datatype(const char *const action) { -// Declared datatypes, - - switch(atoi(action)) - { + switch(atoi(action)) { case 0: MPI_CURRENT_TYPE=MPI_DOUBLE; break; @@ -123,21 +108,18 @@ static MPI_Datatype decode_datatype(const char *const action) break; default: MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE; - } return MPI_CURRENT_TYPE; } - 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){ + if(known!=nullptr) + *known=1; + if (datatype==MPI_BYTE) return ""; - } if(datatype==MPI_DOUBLE) return "0"; if(datatype==MPI_INT) @@ -151,7 +133,8 @@ const char* encode_datatype(MPI_Datatype datatype, int* known) 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; + if(known!=nullptr) + *known=0; // default - not implemented. // do not warn here as we pass in this function even for other trace formats return "-1"; @@ -159,7 +142,7 @@ const char* encode_datatype(MPI_Datatype datatype, int* known) #define CHECK_ACTION_PARAMS(action, mandatory, optional) {\ int i=0;\ - while(action[i]!=NULL)\ + while(action[i]!=nullptr)\ i++;\ if(i); } static void action_finalize(const char *const *action) { + /* do nothing */ } static void action_comm_size(const char *const *action) { - double clock = smpi_process_simulated_elapsed(); - communicator_size = parse_double(action[2]); - log_timed_action (action, clock); + log_timed_action (action, smpi_process_simulated_elapsed()); } static void action_comm_split(const char *const *action) { - double clock = smpi_process_simulated_elapsed(); - - log_timed_action (action, clock); + log_timed_action (action, smpi_process_simulated_elapsed()); } static void action_comm_dup(const char *const *action) { - double clock = smpi_process_simulated_elapsed(); - - log_timed_action (action, clock); + log_timed_action (action, smpi_process_simulated_elapsed()); } static void action_compute(const char *const *action) { - CHECK_ACTION_PARAMS(action, 1, 0); + CHECK_ACTION_PARAMS(action, 1, 0) double clock = smpi_process_simulated_elapsed(); double flops= parse_double(action[2]); int rank = smpi_process_index(); @@ -242,16 +207,15 @@ static void action_compute(const char *const *action) static void action_send(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); - if(action[4]) { + if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - } else { + else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; - } int rank = smpi_process_index(); @@ -261,13 +225,12 @@ 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, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); - if (!TRACE_smpi_view_internals()) { - TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE)); - } + if (!TRACE_smpi_view_internals()) + TRACE_smpi_send(rank, rank, dst_traced, 0, size*smpi_datatype_size(MPI_CURRENT_TYPE)); - smpi_mpi_send(NULL, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD); + smpi_mpi_send(nullptr, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD); log_timed_action (action, clock); @@ -276,14 +239,15 @@ static void action_send(const char *const *action) static void action_Isend(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); - MPI_Request request; - if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + if(action[4]) + MPI_CURRENT_TYPE=decode_datatype(action[4]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; int rank = smpi_process_index(); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); @@ -292,31 +256,32 @@ 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, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); - if (!TRACE_smpi_view_internals()) { - TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE)); - } + if (!TRACE_smpi_view_internals()) + TRACE_smpi_send(rank, rank, dst_traced, 0, size*smpi_datatype_size(MPI_CURRENT_TYPE)); - request = smpi_mpi_isend(NULL, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD); + MPI_Request request = smpi_mpi_isend(nullptr, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD); TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); request->send = 1; - xbt_dynar_push(get_reqq_self(),&request); + get_reqq_self()->push_back(request); log_timed_action (action, clock); } static void action_recv(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) int from = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); MPI_Status status; - if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + if(action[4]) + MPI_CURRENT_TYPE=decode_datatype(action[4]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; int rank = smpi_process_index(); int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from); @@ -326,20 +291,20 @@ 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, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); - //unknow size from the receiver pov - if(size==-1){ - smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status); - size=status.count; + //unknown size from the receiver point of view + if(size<=0.0){ + smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status); + size=status.count; } - smpi_mpi_recv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status); + smpi_mpi_recv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status); TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); if (!TRACE_smpi_view_internals()) { - TRACE_smpi_recv(rank, src_traced, rank); + TRACE_smpi_recv(rank, src_traced, rank, 0); } log_timed_action (action, clock); @@ -347,14 +312,15 @@ static void action_recv(const char *const *action) { static void action_Irecv(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) int from = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); - MPI_Request request; - if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + if(action[4]) + MPI_CURRENT_TYPE=decode_datatype(action[4]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; int rank = smpi_process_index(); int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from); @@ -363,48 +329,45 @@ 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, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); MPI_Status status; //unknow size from the receiver pov - if(size==-1){ + if(size<=0.0){ smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status); size=status.count; } - request = smpi_mpi_irecv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD); + MPI_Request request = smpi_mpi_irecv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD); TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__); request->recv = 1; - xbt_dynar_push(get_reqq_self(),&request); + get_reqq_self()->push_back(request); log_timed_action (action, clock); } static void action_test(const char *const *action){ - CHECK_ACTION_PARAMS(action, 0, 0); + 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(get_reqq_self(),MPI_Request); + MPI_Request request = get_reqq_self()->back(); + get_reqq_self()->pop_back(); //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){ + if(request!=nullptr){ 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); + int 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); + /* push back request in vector to be caught by a subsequent wait. if the test did succeed, the request is now nullptr.*/ + get_reqq_self()->push_back(request); TRACE_smpi_testing_out(rank); } @@ -412,26 +375,21 @@ static void action_test(const char *const *action){ } static void action_wait(const char *const *action){ - CHECK_ACTION_PARAMS(action, 0, 0); + CHECK_ACTION_PARAMS(action, 0, 0) double clock = smpi_process_simulated_elapsed(); - MPI_Request request; MPI_Status status; - xbt_assert(xbt_dynar_length(get_reqq_self()), - "action wait not preceded by any irecv or isend: %s", + xbt_assert(get_reqq_self()->size(), "action wait not preceded by any irecv or isend: %s", xbt_str_join_array(action," ")); - request = xbt_dynar_pop_as(get_reqq_self(),MPI_Request); + MPI_Request request = get_reqq_self()->back(); + get_reqq_self()->pop_back(); - if (!request){ - /* Assuming that the trace is well formed, this mean the comm might have - * been caught by a MPI_test. Then just return. - */ + if (request==nullptr){ + /* Assume that the trace is well formed, meaning the comm might have been caught by a MPI_test. Then just return.*/ return; } - int rank = request->comm != MPI_COMM_NULL - ? smpi_comm_rank(request->comm) - : -1; + int rank = request->comm != MPI_COMM_NULL ? smpi_comm_rank(request->comm) : -1; MPI_Group group = smpi_comm_group(request->comm); int src_traced = smpi_group_rank(group, request->src); @@ -445,78 +403,41 @@ static void action_wait(const char *const *action){ TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__); if (is_wait_for_receive) - TRACE_smpi_recv(rank, src_traced, dst_traced); + TRACE_smpi_recv(rank, src_traced, dst_traced, 0); log_timed_action (action, clock); } static void action_waitall(const char *const *action){ - CHECK_ACTION_PARAMS(action, 0, 0); + 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(get_reqq_self()); + unsigned int count_requests=get_reqq_self()->size(); if (count_requests>0) { - MPI_Request requests[count_requests]; MPI_Status status[count_requests]; - /* 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(get_reqq_self(),i,requests[i]); - - //save information from requests - - xbt_dynar_t srcs = xbt_dynar_new(sizeof(int), NULL); - xbt_dynar_t dsts = xbt_dynar_new(sizeof(int), NULL); - xbt_dynar_t recvs = xbt_dynar_new(sizeof(int), NULL); - for (i = 0; (int)i < count_requests; i++) { - if(requests[i]){ - int *asrc = xbt_new(int, 1); - int *adst = xbt_new(int, 1); - int *arecv = xbt_new(int, 1); - *asrc = requests[i]->src; - *adst = requests[i]->dst; - *arecv = requests[i]->recv; - xbt_dynar_insert_at(srcs, i, asrc); - xbt_dynar_insert_at(dsts, i, adst); - xbt_dynar_insert_at(recvs, i, arecv); - xbt_free(asrc); - xbt_free(adst); - xbt_free(arecv); - }else { - int *t = xbt_new(int, 1); - xbt_dynar_insert_at(srcs, i, t); - xbt_dynar_insert_at(dsts, i, t); - xbt_dynar_insert_at(recvs, i, t); - xbt_free(t); - } - } int rank_traced = smpi_process_index(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_WAITALL; extra->send_size=count_requests; TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra); + int recvs_snd[count_requests]; + int recvs_rcv[count_requests]; + unsigned int i=0; + for (auto req : *(get_reqq_self())){ + if (req && req->recv){ + recvs_snd[i]=req->src; + recvs_rcv[i]=req->dst; + }else + recvs_snd[i]=-100; + i++; + } + smpi_mpi_waitall(count_requests, &(*get_reqq_self())[0], status); - smpi_mpi_waitall(count_requests, requests, status); - - for (i = 0; (int)i < count_requests; i++) { - int src_traced, dst_traced, is_wait_for_receive; - xbt_dynar_get_cpy(srcs, i, &src_traced); - xbt_dynar_get_cpy(dsts, i, &dst_traced); - xbt_dynar_get_cpy(recvs, i, &is_wait_for_receive); - if (is_wait_for_receive) { - TRACE_smpi_recv(rank_traced, src_traced, dst_traced); - } + for (i=0; itype = TRACING_BCAST; extra->send_size = size; extra->root = root_traced; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra); void *sendbuf = smpi_get_tmp_sendbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE)); @@ -573,7 +490,7 @@ static void action_bcast(const char *const *action) static void action_reduce(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 2); + 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(); @@ -586,8 +503,6 @@ static void action_reduce(const char *const *action) MPI_CURRENT_TYPE=decode_datatype(action[5]); } } - - int rank = smpi_process_index(); int root_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), root); @@ -595,27 +510,29 @@ static void action_reduce(const char *const *action) extra->type = TRACING_REDUCE; extra->send_size = comm_size; extra->comp_size = comp_size; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); extra->root = root_traced; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra); 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); + mpi_coll_reduce_fun(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, root, MPI_COMM_WORLD); + smpi_execute_flops(comp_size); TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); log_timed_action (action, clock); } static void action_allReduce(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) double comm_size = parse_double(action[2]); double comp_size = parse_double(action[3]); - if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + if(action[4]) + MPI_CURRENT_TYPE=decode_datatype(action[4]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; double clock = smpi_process_simulated_elapsed(); int rank = smpi_process_index(); @@ -623,7 +540,7 @@ static void action_allReduce(const char *const *action) { extra->type = TRACING_ALLREDUCE; extra->send_size = comm_size; extra->comp_size = comp_size; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); @@ -636,13 +553,13 @@ static void action_allReduce(const char *const *action) { } static void action_allToAll(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 2); //two mandatory (send and recv volumes) + CHECK_ACTION_PARAMS(action, 2, 2) //two mandatory (send and recv volumes) //two optional (corresponding datatypes) double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); int send_size = parse_double(action[2]); int recv_size = parse_double(action[3]); - MPI_Datatype MPI_CURRENT_TYPE2; + MPI_Datatype MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE; if(action[4] && action[5]) { MPI_CURRENT_TYPE=decode_datatype(action[4]); @@ -650,7 +567,6 @@ static void action_allToAll(const char *const *action) { } else{ MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE; - MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE; } void *send = smpi_get_tmp_sendbuffer(send_size*comm_size* smpi_datatype_size(MPI_CURRENT_TYPE)); @@ -661,8 +577,8 @@ static void action_allToAll(const char *const *action) { extra->type = TRACING_ALLTOALL; extra->send_size = send_size; extra->recv_size = recv_size; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr); TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); @@ -672,35 +588,30 @@ static void action_allToAll(const char *const *action) { log_timed_action (action, clock); } - static void action_gather(const char *const *action) { - /* - The structure of the gather action for the rank 0 (total 4 processes) - is the following: - 0 gather 68 68 0 0 0 - - where: - 1) 68 is the sendcounts - 2) 68 is the recvcounts - 3) 0 is the root node - 4) 0 is the send datatype id, see decode_datatype() - 5) 0 is the recv datatype id, see decode_datatype() + /* The structure of the gather action for the rank 0 (total 4 processes) is the following: + 0 gather 68 68 0 0 0 + where: + 1) 68 is the sendcounts + 2) 68 is the recvcounts + 3) 0 is the root node + 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); + 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]); int recv_size = parse_double(action[3]); - MPI_Datatype MPI_CURRENT_TYPE2; + MPI_Datatype MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE; if(action[4] && action[5]) { MPI_CURRENT_TYPE=decode_datatype(action[5]); MPI_CURRENT_TYPE2=decode_datatype(action[6]); } else { MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE; - MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE; } void *send = smpi_get_tmp_sendbuffer(send_size* smpi_datatype_size(MPI_CURRENT_TYPE)); - void *recv = NULL; + void *recv = nullptr; int root=0; if(action[4]) root=atoi(action[4]); @@ -714,61 +625,52 @@ static void action_gather(const char *const *action) { extra->send_size = send_size; extra->recv_size = recv_size; extra->root = root; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr); TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra); - mpi_coll_gather_fun(send, send_size, MPI_CURRENT_TYPE, - recv, recv_size, MPI_CURRENT_TYPE2, - root, MPI_COMM_WORLD); + mpi_coll_gather_fun(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD); TRACE_smpi_collective_out(smpi_process_index(), -1, __FUNCTION__); log_timed_action (action, clock); } - - static void action_gatherv(const char *const *action) { - /* - The structure of the gatherv action for the rank 0 (total 4 processes) - is the following: - 0 gather 68 68 10 10 10 0 0 0 - - where: - 1) 68 is the sendcount - 2) 68 10 10 10 is the recvcounts - 3) 0 is the root node - 4) 0 is the send datatype id, see decode_datatype() - 5) 0 is the recv datatype id, see decode_datatype() + /* The structure of the gatherv action for the rank 0 (total 4 processes) is the following: + 0 gather 68 68 10 10 10 0 0 0 + where: + 1) 68 is the sendcount + 2) 68 10 10 10 is the recvcounts + 3) 0 is the root node + 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); + 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); + int disps[comm_size] = { 0 }; + int recvcounts[comm_size]; int i=0,recv_sum=0; - MPI_Datatype MPI_CURRENT_TYPE2; + MPI_Datatype MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE; if(action[4+comm_size] && action[5+comm_size]) { MPI_CURRENT_TYPE=decode_datatype(action[4+comm_size]); MPI_CURRENT_TYPE2=decode_datatype(action[5+comm_size]); } else { MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE; - MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE; } void *send = smpi_get_tmp_sendbuffer(send_size* smpi_datatype_size(MPI_CURRENT_TYPE)); - void *recv = NULL; + void *recv = nullptr; for(i=0;irecvcounts[i] = recvcounts[i]; extra->root = root; extra->num_processes = comm_size; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr); TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra); - smpi_mpi_gatherv(send, send_size, MPI_CURRENT_TYPE, - recv, recvcounts, disps, MPI_CURRENT_TYPE2, - root, MPI_COMM_WORLD); + smpi_mpi_gatherv(send, send_size, MPI_CURRENT_TYPE, recv, recvcounts, disps, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD); TRACE_smpi_collective_out(smpi_process_index(), -1, __FUNCTION__); log_timed_action (action, clock); - xbt_free(recvcounts); - xbt_free(disps); } static void action_reducescatter(const char *const *action) { - - /* - The structure of the reducescatter action for the rank 0 (total 4 processes) - is the following: -0 reduceScatter 275427 275427 275427 204020 11346849 0 - - where: - 1) The first four values after the name of the action declare the recvcounts array - 2) The value 11346849 is the amount of instructions - 3) The last value corresponds to the datatype, see decode_datatype(). - - We analyze a MPI_Reduce_scatter call to one MPI_Reduce and one MPI_Scatterv. - - */ - + /* The structure of the reducescatter action for the rank 0 (total 4 processes) is the following: + 0 reduceScatter 275427 275427 275427 204020 11346849 0 + where: + 1) The first four values after the name of the action declare the recvcounts array + 2) The value 11346849 is the amount of instructions + 3) The last value corresponds to the datatype, 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, 1); + 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); - int i=0; + int recvcounts[comm_size]; int rank = smpi_process_index(); int size = 0; if(action[3+comm_size]) @@ -826,9 +714,8 @@ static void action_reducescatter(const char *const *action) { else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; - for(i=0;itype = TRACING_REDUCE_SCATTER; extra->send_size = 0; extra->recvcounts= xbt_new(int, comm_size); - for(i=0; i< comm_size; i++)//copy data to avoid bad free + for(int i=0; i< comm_size; i++)//copy data to avoid bad free extra->recvcounts[i] = recvcounts[i]; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); extra->comp_size = comp_size; extra->num_processes = comm_size; @@ -846,46 +733,35 @@ static void action_reducescatter(const char *const *action) { 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)); - - mpi_coll_reduce_scatter_fun(sendbuf, recvbuf, recvcounts, MPI_CURRENT_TYPE, MPI_OP_NULL, - MPI_COMM_WORLD); - smpi_execute_flops(comp_size); + mpi_coll_reduce_scatter_fun(sendbuf, recvbuf, recvcounts, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD); + smpi_execute_flops(comp_size); TRACE_smpi_collective_out(rank, -1, __FUNCTION__); - 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(). - - */ - + /* 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); + CHECK_ACTION_PARAMS(action, 2, 2) int sendcount=atoi(action[2]); int recvcount=atoi(action[3]); - MPI_Datatype MPI_CURRENT_TYPE2; + MPI_Datatype MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE; if(action[4] && action[5]) { MPI_CURRENT_TYPE = decode_datatype(action[4]); MPI_CURRENT_TYPE2 = decode_datatype(action[5]); } 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)); @@ -895,8 +771,8 @@ static void action_allgather(const char *const *action) { 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->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr); extra->num_processes = smpi_comm_size(MPI_COMM_WORLD); TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); @@ -908,41 +784,32 @@ static void action_allgather(const char *const *action) { } static void action_allgatherv(const char *const *action) { - - /* - The structure of the allgatherv action for the rank 0 (total 4 processes) - is the following: -0 allGatherV 275427 275427 275427 275427 204020 - - where: - 1) 275427 is the sendcount - 2) The next four elements declare the recvcounts array - 3) No more values mean that the datatype for sent and receive buffer - is the default one, see decode_datatype(). - - */ - + /* The structure of the allgatherv action for the rank 0 (total 4 processes) is the following: + 0 allGatherV 275427 275427 275427 275427 204020 + where: + 1) 275427 is the sendcount + 2) The next four elements declare the recvcounts array + 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(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); - CHECK_ACTION_PARAMS(action, comm_size+1, 2); - int i=0; + CHECK_ACTION_PARAMS(action, comm_size+1, 2) int sendcount=atoi(action[2]); - int *recvcounts = xbt_new0(int, comm_size); - int *disps = xbt_new0(int, comm_size); - int recv_sum=0; - MPI_Datatype MPI_CURRENT_TYPE2; + int recvcounts[comm_size]; + int disps[comm_size] = { 0 }; + int recv_sum=0; + MPI_Datatype MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE; if(action[3+comm_size] && action[4+comm_size]) { MPI_CURRENT_TYPE = decode_datatype(action[3+comm_size]); MPI_CURRENT_TYPE2 = decode_datatype(action[4+comm_size]); } 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)); - for(i=0;itype = TRACING_ALLGATHERV; extra->send_size = sendcount; extra->recvcounts= xbt_new(int, comm_size); - for(i=0; i< comm_size; i++)//copy data to avoid bad free + for(int i=0; i< comm_size; i++)//copy data to avoid bad free extra->recvcounts[i] = recvcounts[i]; - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr); extra->num_processes = comm_size; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); - mpi_coll_allgatherv_fun(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2, MPI_COMM_WORLD); + mpi_coll_allgatherv_fun(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2, + MPI_COMM_WORLD); TRACE_smpi_collective_out(rank, -1, __FUNCTION__); 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) - is the following: - 0 allToAllV 100 1 7 10 12 100 1 70 10 5 - - where: - 1) 100 is the size of the send buffer *sizeof(int), - 2) 1 7 10 12 is the sendcounts array - 3) 100*sizeof(int) is the size of the receiver buffer - 4) 1 70 10 5 is the recvcounts array - - */ - - + /* The structure of the allToAllV action for the rank 0 (total 4 processes) is the following: + 0 allToAllV 100 1 7 10 12 100 1 70 10 5 + where: + 1) 100 is the size of the send buffer *sizeof(int), + 2) 1 7 10 12 is the sendcounts array + 3) 100*sizeof(int) is the size of the receiver buffer + 4) 1 70 10 5 is the recvcounts array + */ 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); - int *senddisps = xbt_new0(int, comm_size); - int *recvdisps = xbt_new0(int, comm_size); + CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2) + int sendcounts[comm_size]; + int recvcounts[comm_size]; + int senddisps[comm_size] = { 0 }; + int recvdisps[comm_size] = { 0 }; - MPI_Datatype MPI_CURRENT_TYPE2; + MPI_Datatype MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE; - send_buf_size=parse_double(action[2]); - recv_buf_size=parse_double(action[3+comm_size]); + int send_buf_size=parse_double(action[2]); + int recv_buf_size=parse_double(action[3+comm_size]); if(action[4+2*comm_size] && action[5+2*comm_size]) { MPI_CURRENT_TYPE=decode_datatype(action[4+2*comm_size]); MPI_CURRENT_TYPE2=decode_datatype(action[5+2*comm_size]); } else{ MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE; - MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE; } void *sendbuf = smpi_get_tmp_sendbuffer(send_buf_size* smpi_datatype_size(MPI_CURRENT_TYPE)); void *recvbuf = smpi_get_tmp_recvbuffer(recv_buf_size* smpi_datatype_size(MPI_CURRENT_TYPE2)); - for(i=0;itype = TRACING_ALLTOALLV; @@ -1023,34 +880,29 @@ static void action_allToAllv(const char *const *action) { extra->sendcounts= xbt_new(int, comm_size); extra->num_processes = comm_size; - for(i=0; i< comm_size; i++){//copy data to avoid bad free + for(int i=0; i< comm_size; i++){//copy data to avoid bad free extra->send_size += sendcounts[i]; extra->sendcounts[i] = sendcounts[i]; extra->recv_size += recvcounts[i]; extra->recvcounts[i] = recvcounts[i]; } - extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL); - extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL); + extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr); + extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr); TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); - mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE, - recvbuf, recvcounts, recvdisps, MPI_CURRENT_TYPE, - MPI_COMM_WORLD); + mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE,recvbuf, recvcounts, recvdisps, + MPI_CURRENT_TYPE, MPI_COMM_WORLD); TRACE_smpi_collective_out(rank, -1, __FUNCTION__); log_timed_action (action, clock); - xbt_free(sendcounts); - xbt_free(recvcounts); - xbt_free(senddisps); - xbt_free(recvdisps); } void smpi_replay_run(int *argc, char***argv){ /* First initializes everything */ smpi_process_init(argc, argv); smpi_process_mark_as_initialized(); - smpi_process_set_replaying(1); + smpi_process_set_replaying(true); int rank = smpi_process_index(); TRACE_smpi_init(rank); @@ -1060,9 +912,9 @@ void smpi_replay_run(int *argc, char***argv){ char *operation =bprintf("%s_init",__FUNCTION__); TRACE_smpi_collective_in(rank, -1, operation, extra); TRACE_smpi_collective_out(rank, -1, operation); - free(operation); + xbt_free(operation); - if (!_xbt_replay_action_init()) { + if (_xbt_replay_action_init()==0) { xbt_replay_action_register("init", action_init); xbt_replay_action_register("finalize", action_finalize); xbt_replay_action_register("comm_size", action_comm_size); @@ -1088,7 +940,7 @@ void smpi_replay_run(int *argc, char***argv){ xbt_replay_action_register("reduceScatter", action_reducescatter); xbt_replay_action_register("compute", action_compute); } - + //if we have a delayed start, sleep here. if(*argc>2){ char *endptr; @@ -1102,47 +954,35 @@ void smpi_replay_run(int *argc, char***argv){ XBT_DEBUG("Force context switch by smpi_execute_flops - Sleeping for 0.0 flops "); smpi_execute_flops(0.0); } - + /* Actually run the replay */ xbt_replay_action_runner(*argc, *argv); /* and now, finalize everything */ - double sim_time= 1.; /* One active process will stop. Decrease the counter*/ - XBT_DEBUG("There are %lu elements in reqq[*]", - xbt_dynar_length(get_reqq_self())); - if (!xbt_dynar_is_empty(get_reqq_self())){ - int count_requests=xbt_dynar_length(get_reqq_self()); + XBT_DEBUG("There are %zu elements in reqq[*]", get_reqq_self()->size()); + if (!get_reqq_self()->empty()){ + unsigned int count_requests=get_reqq_self()->size(); MPI_Request requests[count_requests]; MPI_Status status[count_requests]; - unsigned int i; + unsigned int i=0; - xbt_dynar_foreach(get_reqq_self(),i,requests[i]); + for (auto req: *get_reqq_self()){ + requests[i] = req; + i++; + } smpi_mpi_waitall(count_requests, requests, status); - active_processes--; - } else { - active_processes--; - } - - if(!active_processes){ - /* Last process alive speaking */ - /* end the simulated timer */ - sim_time = smpi_process_simulated_elapsed(); } - - - //TODO xbt_dynar_free_container(get_reqq_self())); + active_processes--; - if(!active_processes){ - XBT_INFO("Simulation time %f", sim_time); + if(active_processes==0){ + /* Last process alive speaking: end the simulated timer */ + XBT_INFO("Simulation time %f", smpi_process_simulated_elapsed()); _xbt_replay_action_exit(); xbt_free(sendbuffer); xbt_free(recvbuffer); - //xbt_free(reqq); - xbt_dict_free(&reqq); //not need, data have been freed ??? - reqq = NULL; } - + instr_extra_data extra_fin = xbt_new0(s_instr_extra_data_t,1); extra_fin->type = TRACING_FINALIZE; operation =bprintf("%s_finalize",__FUNCTION__); @@ -1153,5 +993,5 @@ void smpi_replay_run(int *argc, char***argv){ TRACE_smpi_collective_out(rank, -1, operation); TRACE_smpi_finalize(smpi_process_index()); smpi_process_destroy(); - free(operation); + xbt_free(operation); }