summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
7634631)
What is new:
1) For most of the collective communications we can know exactly which rank is the root one.
2) Now we can include in the traces the real used MPI datatype (till know we were using the MPI_BYTE). Also we can have multiple datatypes in the traces.
3) The tool supports both time-independent traces from the TAU and the modified MPE tools.
4) Fix Reduce action, as there was no information about computation load.
#include <xbt.h>
#include <xbt/replay.h>
#include <xbt.h>
#include <xbt/replay.h>
-#define MPI_DTYPE MPI_BYTE
-
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;
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;
+MPI_Datatype MPI_DEFAULT_TYPE, MPI_CURRENT_TYPE;
+
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, " ");
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, " ");
typedef struct {
xbt_dynar_t isends; /* of MPI_Request */
xbt_dynar_t irecvs; /* of MPI_Request */
typedef struct {
xbt_dynar_t isends; /* of MPI_Request */
xbt_dynar_t irecvs; /* of MPI_Request */
+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;
static void action_init(const char *const *action)
{
int i;
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);
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);
smpi_process_set_user_data((void*) globals);
for(i=0;i<active_processes;i++){
reqq[i]=xbt_dynar_new(sizeof(MPI_Request),NULL);
}
for(i=0;i<active_processes;i++){
reqq[i]=xbt_dynar_new(sizeof(MPI_Request),NULL);
}
}
static void action_finalize(const char *const *action)
{
smpi_replay_globals_t globals =
(smpi_replay_globals_t) smpi_process_get_user_data();
}
static void action_finalize(const char *const *action)
{
smpi_replay_globals_t globals =
(smpi_replay_globals_t) smpi_process_get_user_data();
if (globals){
XBT_DEBUG("There are %lu isends and %lu irecvs in the dynars",
xbt_dynar_length(globals->isends),xbt_dynar_length(globals->irecvs));
if (globals){
XBT_DEBUG("There are %lu isends and %lu irecvs in the dynars",
xbt_dynar_length(globals->isends),xbt_dynar_length(globals->irecvs));
int to = atoi(action[2]);
double size=parse_double(action[3]);
double clock = smpi_process_simulated_elapsed();
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);
#ifdef HAVE_TRACING
int rank = smpi_comm_rank(MPI_COMM_WORLD);
TRACE_smpi_computing_out(rank);
TRACE_smpi_send(rank, rank, dst_traced);
#endif
TRACE_smpi_send(rank, rank, dst_traced);
#endif
- smpi_mpi_send(NULL, size, MPI_DTYPE, to , 0, MPI_COMM_WORLD);
+ smpi_mpi_send(NULL, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD);
log_timed_action (action, clock);
log_timed_action (action, clock);
double size=parse_double(action[3]);
double clock = smpi_process_simulated_elapsed();
MPI_Request request;
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;
+
smpi_replay_globals_t globals =
(smpi_replay_globals_t) smpi_process_get_user_data();
#ifdef HAVE_TRACING
smpi_replay_globals_t globals =
(smpi_replay_globals_t) smpi_process_get_user_data();
#ifdef HAVE_TRACING
TRACE_smpi_send(rank, rank, dst_traced);
#endif
TRACE_smpi_send(rank, rank, dst_traced);
#endif
- request = smpi_mpi_isend(NULL, size, MPI_DTYPE, 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__);
#ifdef HAVE_TRACING
TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
double size=parse_double(action[3]);
double clock = smpi_process_simulated_elapsed();
MPI_Status status;
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);
#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__);
#endif
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
#endif
- smpi_mpi_recv(NULL, size, MPI_DTYPE, 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__);
#ifdef HAVE_TRACING
TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
double size=parse_double(action[3]);
double clock = smpi_process_simulated_elapsed();
MPI_Request request;
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();
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);
#ifdef HAVE_TRACING
int rank = smpi_comm_rank(MPI_COMM_WORLD);
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
#endif
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
#endif
- request = smpi_mpi_irecv(NULL, size, MPI_DTYPE, 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__);
#ifdef HAVE_TRACING
TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
log_timed_action (action, clock);
}
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();
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);
#ifdef HAVE_TRACING
int rank = smpi_comm_rank(MPI_COMM_WORLD);
TRACE_smpi_computing_out(rank);
TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
#endif
TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
#endif
- smpi_mpi_bcast(NULL, size, MPI_DTYPE, 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);
#ifdef HAVE_TRACING
TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
TRACE_smpi_computing_in(rank);
static void action_reduce(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();
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__);
#endif
#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__);
#endif
- smpi_mpi_reduce(NULL, NULL, size, MPI_DTYPE, MPI_OP_NULL, 0, MPI_COMM_WORLD);
+ smpi_mpi_reduce(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);
#ifdef HAVE_TRACING
TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
TRACE_smpi_computing_in(rank);
static void action_allReduce(const char *const *action) {
double comm_size = parse_double(action[2]);
double comp_size = parse_double(action[3]);
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__);
#endif
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__);
#endif
- smpi_mpi_reduce(NULL, NULL, comm_size, MPI_DTYPE, MPI_OP_NULL, 0, MPI_COMM_WORLD);
+ smpi_mpi_reduce(NULL, NULL, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, 0, MPI_COMM_WORLD);
smpi_execute_flops(comp_size);
smpi_execute_flops(comp_size);
- smpi_mpi_bcast(NULL, comm_size, MPI_DTYPE, 0, MPI_COMM_WORLD);
+ smpi_mpi_bcast(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);
#ifdef HAVE_TRACING
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
TRACE_smpi_computing_in(rank);
int recv_size = atoi(action[3]);
void *send = xbt_new0(int, send_size*comm_size);
void *recv = xbt_new0(int, send_size*comm_size);
int recv_size = atoi(action[3]);
void *send = xbt_new0(int, send_size*comm_size);
void *recv = xbt_new0(int, send_size*comm_size);
+
+ 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();
#ifdef HAVE_TRACING
int rank = smpi_process_index();
#endif
if (send_size < 200 && comm_size > 12) {
#endif
if (send_size < 200 && comm_size > 12) {
- smpi_coll_tuned_alltoall_bruck(send, send_size, MPI_DTYPE,
- recv, recv_size, MPI_DTYPE,
+ smpi_coll_tuned_alltoall_bruck(send, send_size, MPI_CURRENT_TYPE,
+ recv, recv_size, MPI_CURRENT_TYPE,
MPI_COMM_WORLD);
} else if (send_size < 3000) {
MPI_COMM_WORLD);
} else if (send_size < 3000) {
- smpi_coll_tuned_alltoall_basic_linear(send, send_size, MPI_DTYPE,
- recv, recv_size, MPI_DTYPE,
+ smpi_coll_tuned_alltoall_basic_linear(send, send_size, MPI_CURRENT_TYPE,
+ recv, recv_size, MPI_CURRENT_TYPE,
MPI_COMM_WORLD);
} else {
MPI_COMM_WORLD);
} else {
- smpi_coll_tuned_alltoall_pairwise(send, send_size, MPI_DTYPE,
- recv, recv_size, MPI_DTYPE,
+ smpi_coll_tuned_alltoall_pairwise(send, send_size, MPI_CURRENT_TYPE,
+ recv, recv_size, MPI_CURRENT_TYPE,
int *recvcounts = xbt_new0(int, comm_size);
int *senddisps = xbt_new0(int, comm_size);
int *recvdisps = 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);
- MPI_Datatype sendtype,recvtype;
send_buf_size=atoi(action[2]);
recv_buf_size=atoi(action[3+2*comm_size]);
send_buf_size=atoi(action[2]);
recv_buf_size=atoi(action[3+2*comm_size]);
int *sendbuf = xbt_new0(int, send_buf_size);
int *recvbuf = xbt_new0(int, recv_buf_size);
int *sendbuf = xbt_new0(int, send_buf_size);
int *recvbuf = xbt_new0(int, recv_buf_size);
- sendtype=MPI_DTYPE;
- recvtype=MPI_DTYPE;
-
+ if(action[4+4*comm_size]) MPI_CURRENT_TYPE=decode_datatype(action[4+4*comm_size]);
+ else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
+
for(i=0;i<comm_size;i++) {
sendcounts[i] = atoi(action[i+3]);
senddisps[i] = atoi(action[i+3+comm_size]);
for(i=0;i<comm_size;i++) {
sendcounts[i] = atoi(action[i+3]);
senddisps[i] = atoi(action[i+3+comm_size]);
TRACE_smpi_computing_out(rank);
TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
#endif
TRACE_smpi_computing_out(rank);
TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
#endif
- smpi_coll_basic_alltoallv(sendbuf, sendcounts, senddisps, sendtype,
- recvbuf, recvcounts, recvdisps, recvtype,
+ smpi_coll_basic_alltoallv(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__);
MPI_COMM_WORLD);
#ifdef HAVE_TRACING
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);