X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c5c22f37a485155dc3b19de10336cc67d6ec688a..c9850ddfb4fcfe07741b9709c1bdb0a7d1e2f0b7:/src/smpi/smpi_replay.c diff --git a/src/smpi/smpi_replay.c b/src/smpi/smpi_replay.c index 77b059c5f6..fbfb10709d 100644 --- a/src/smpi/smpi_replay.c +++ b/src/smpi/smpi_replay.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2009, 2010, 2011, 2012. The SimGrid Team. +/* Copyright (c) 2009-2013. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -14,6 +14,10 @@ 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; + +MPI_Datatype MPI_DEFAULT_TYPE; +MPI_Datatype MPI_CURRENT_TYPE; static void log_timed_action (const char *const *action, double clock){ if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){ @@ -24,10 +28,10 @@ static void log_timed_action (const char *const *action, double clock){ } typedef struct { - xbt_dynar_t isends; /* of MPI_Request */ xbt_dynar_t irecvs; /* of MPI_Request */ } s_smpi_replay_globals_t, *smpi_replay_globals_t; + /* Helper function */ static double parse_double(const char *string) { @@ -39,30 +43,73 @@ static double parse_double(const char *string) return value; } +static MPI_Datatype decode_datatype(const char *const action) +{ +// Declared datatypes, + + switch(atoi(action)) + { + case 0: + MPI_CURRENT_TYPE=MPI_DOUBLE; + break; + case 1: + MPI_CURRENT_TYPE=MPI_INT; + break; + case 2: + MPI_CURRENT_TYPE=MPI_CHAR; + break; + case 3: + MPI_CURRENT_TYPE=MPI_SHORT; + break; + case 4: + MPI_CURRENT_TYPE=MPI_LONG; + break; + case 5: + MPI_CURRENT_TYPE=MPI_FLOAT; + break; + case 6: + MPI_CURRENT_TYPE=MPI_BYTE; + break; + default: + MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE; + + } + return MPI_CURRENT_TYPE; +} + static void action_init(const char *const *action) { + int i; XBT_DEBUG("Initialize the counters"); smpi_replay_globals_t globals = xbt_new(s_smpi_replay_globals_t, 1); - globals->isends = xbt_dynar_new(sizeof(MPI_Request),NULL); globals->irecvs = xbt_dynar_new(sizeof(MPI_Request),NULL); + if(action[2]) MPI_DEFAULT_TYPE= MPI_DOUBLE; // default MPE dataype + else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype + smpi_process_set_user_data((void*) globals); /* start a simulated timer */ smpi_process_simulated_start(); /*initialize the number of active processes */ active_processes = smpi_process_count(); + + if (!reqq) { + reqq=xbt_new0(xbt_dynar_t,active_processes); + + for(i=0;iisends),xbt_dynar_length(globals->irecvs)); - xbt_dynar_free_container(&(globals->isends)); + XBT_DEBUG("There are %lu irecvs in the dynar", + xbt_dynar_length(globals->irecvs)); xbt_dynar_free_container(&(globals->irecvs)); } free(globals); @@ -103,15 +150,22 @@ static void action_send(const char *const *action) int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); + + if(action[4]) { + MPI_CURRENT_TYPE=decode_datatype(action[4]); + } else { + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + } + #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); - TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__); - TRACE_smpi_send(rank, rank, dst_traced); + TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, size*smpi_datatype_size(MPI_CURRENT_TYPE)); + TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE)); #endif - smpi_mpi_send(NULL, size, MPI_BYTE, to , 0, MPI_COMM_WORLD); + smpi_mpi_send(NULL, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD); log_timed_action (action, clock); @@ -127,25 +181,28 @@ static void action_Isend(const char *const *action) int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); - smpi_replay_globals_t globals = - (smpi_replay_globals_t) smpi_process_get_user_data(); + MPI_Request request; + + if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); + else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); - TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__); - TRACE_smpi_send(rank, rank, dst_traced); + TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, size*smpi_datatype_size(MPI_CURRENT_TYPE)); + TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE)); #endif - MPI_Request request = smpi_mpi_isend(NULL, size, MPI_BYTE, to, 0, - MPI_COMM_WORLD); + 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; TRACE_smpi_computing_in(rank); #endif - xbt_dynar_push(globals->isends,&request); + xbt_dynar_push(reqq[smpi_comm_rank(MPI_COMM_WORLD)],&request); log_timed_action (action, clock); } @@ -155,15 +212,19 @@ static void action_recv(const char *const *action) { 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; + #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from); TRACE_smpi_computing_out(rank); - TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__); + TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, size*smpi_datatype_size(MPI_CURRENT_TYPE)); #endif - smpi_mpi_recv(NULL, size, MPI_BYTE, from, 0, MPI_COMM_WORLD, &status); + 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__); @@ -180,21 +241,27 @@ static void action_Irecv(const char *const *action) double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); MPI_Request request; + smpi_replay_globals_t globals = (smpi_replay_globals_t) smpi_process_get_user_data(); + if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); + else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from); - TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__); + TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, size*smpi_datatype_size(MPI_CURRENT_TYPE)); #endif - request = smpi_mpi_irecv(NULL, size, MPI_BYTE, from, 0, MPI_COMM_WORLD); + 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(globals->irecvs,&request); + xbt_dynar_push(reqq[smpi_comm_rank(MPI_COMM_WORLD)],&request); log_timed_action (action, clock); } @@ -220,7 +287,7 @@ static void action_wait(const char *const *action){ int src_traced = smpi_group_rank(group, request->src); int dst_traced = smpi_group_rank(group, request->dst); int is_wait_for_receive = request->recv; - TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__); + TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, -1); #endif smpi_mpi_wait(&request, &status); #ifdef HAVE_TRACING @@ -236,7 +303,75 @@ static void action_wait(const char *const *action){ static void action_waitall(const char *const *action){ double clock = smpi_process_simulated_elapsed(); -// smpi_mpi_waitall(count, requests, status); + int count_requests=0; + unsigned int i=0; + + count_requests=xbt_dynar_length(reqq[smpi_comm_rank(MPI_COMM_WORLD)]); + + 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(reqq[smpi_comm_rank(MPI_COMM_WORLD)],i,requests[i]); + + #ifdef HAVE_TRACING + //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; 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(); + TRACE_smpi_computing_out(rank_traced); + + TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__, count_requests); + #endif + + 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); + 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); + } + } + TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__); + //clean-up of dynars + xbt_dynar_free(&srcs); + xbt_dynar_free(&dsts); + xbt_dynar_free(&recvs); + TRACE_smpi_computing_in(rank_traced); + #endif + + xbt_dynar_reset(reqq[smpi_comm_rank(MPI_COMM_WORLD)]); + } log_timed_action (action, clock); } @@ -245,7 +380,7 @@ static void action_barrier(const char *const *action){ #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); - TRACE_smpi_collective_in(rank, -1, __FUNCTION__); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__, smpi_comm_size(MPI_COMM_WORLD)); #endif smpi_mpi_barrier(MPI_COMM_WORLD); #ifdef HAVE_TRACING @@ -256,18 +391,33 @@ static void action_barrier(const char *const *action){ log_timed_action (action, clock); } + static void action_bcast(const char *const *action) { double size = parse_double(action[2]); double clock = smpi_process_simulated_elapsed(); + int root=0; + /* + * Initialize MPI_CURRENT_TYPE in order to decrease + * the number of the checks + * */ + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + + if(action[3]) { + root= atoi(action[3]); + if(action[4]) { + MPI_CURRENT_TYPE=decode_datatype(action[4]); + } + } + #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); int root_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), 0); - TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__); + TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,size*smpi_datatype_size(MPI_CURRENT_TYPE)); #endif - smpi_mpi_bcast(NULL, size, MPI_BYTE, 0, MPI_COMM_WORLD); + smpi_mpi_bcast(NULL, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD); #ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__); TRACE_smpi_computing_in(rank); @@ -278,15 +428,27 @@ static void action_bcast(const char *const *action) static void action_reduce(const char *const *action) { - double size = parse_double(action[2]); + double comm_size = parse_double(action[2]); + double comp_size = parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); + int root=0; + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + + if(action[4]) { + root= atoi(action[4]); + if(action[5]) { + MPI_CURRENT_TYPE=decode_datatype(action[5]); + } + } + #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); int root_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), 0); - TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__); + TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,comm_size*smpi_datatype_size(MPI_CURRENT_TYPE)); #endif - smpi_mpi_reduce(NULL, NULL, size, MPI_BYTE, MPI_OP_NULL, 0, MPI_COMM_WORLD); + mpi_coll_reduce_fun(NULL, NULL, 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__); TRACE_smpi_computing_in(rank); @@ -298,15 +460,19 @@ static void action_reduce(const char *const *action) static void action_allReduce(const char *const *action) { 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; + double clock = smpi_process_simulated_elapsed(); #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); - TRACE_smpi_collective_in(rank, -1, __FUNCTION__); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__,comp_size*smpi_datatype_size(MPI_CURRENT_TYPE)); #endif - smpi_mpi_reduce(NULL, NULL, comm_size, MPI_BYTE, MPI_OP_NULL, 0, MPI_COMM_WORLD); + mpi_coll_reduce_fun(NULL, NULL, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, 0, MPI_COMM_WORLD); smpi_execute_flops(comp_size); - smpi_mpi_bcast(NULL, comm_size, MPI_BYTE, 0, MPI_COMM_WORLD); + mpi_coll_bcast_fun(NULL, comm_size, MPI_CURRENT_TYPE, 0, MPI_COMM_WORLD); #ifdef HAVE_TRACING TRACE_smpi_collective_out(rank, -1, __FUNCTION__); TRACE_smpi_computing_in(rank); @@ -317,14 +483,279 @@ static void action_allReduce(const char *const *action) { static void action_allToAll(const char *const *action) { 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; + + if(action[4]) { + 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 *send = calloc(send_size*comm_size, smpi_datatype_size(MPI_CURRENT_TYPE)); + void *recv = calloc(recv_size*comm_size, smpi_datatype_size(MPI_CURRENT_TYPE2)); + +#ifdef HAVE_TRACING + int rank = smpi_process_index(); + TRACE_smpi_computing_out(rank); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__,send_size*smpi_datatype_size(MPI_CURRENT_TYPE)); +#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__); + TRACE_smpi_computing_in(rank); +#endif log_timed_action (action, clock); + xbt_free(send); + xbt_free(recv); } + +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() + */ + 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; + if(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 = calloc(send_size, smpi_datatype_size(MPI_CURRENT_TYPE)); + void *recv = calloc(recv_size, smpi_datatype_size(MPI_CURRENT_TYPE2)); + + int root=atoi(action[4]); + int rank = smpi_process_index(); + + if(rank==root) + recv = calloc(recv_size*comm_size, smpi_datatype_size(MPI_CURRENT_TYPE2)); + +#ifdef HAVE_TRACING + TRACE_smpi_computing_out(rank); + TRACE_smpi_collective_in(rank, -1, __FUNCTION__,send_size*smpi_datatype_size(MPI_CURRENT_TYPE)); +#endif +smpi_mpi_gather(send, send_size, MPI_CURRENT_TYPE, + recv, recv_size, MPI_CURRENT_TYPE2, + root, MPI_COMM_WORLD); + +#ifdef HAVE_TRACING + TRACE_smpi_collective_out(rank, -1, __FUNCTION__); + TRACE_smpi_computing_in(rank); +#endif + + log_timed_action (action, clock); + xbt_free(send); + xbt_free(recv); +} + + +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. + + */ + + double clock = smpi_process_simulated_elapsed(); + int comm_size = smpi_comm_size(MPI_COMM_WORLD); + 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,recv_sum=0; + int root=0; + int rank = smpi_process_index(); + + if(action[3+comm_size]) + MPI_CURRENT_TYPE=decode_datatype(action[3+comm_size]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + + for(i=0;i