return container;
}
-static char *TRACE_smpi_get_key(int src, int dst, char *key, int n, int send);
+static char *TRACE_smpi_get_key(int src, int dst, int tag, char *key, int n, int send);
-static char *TRACE_smpi_put_key(int src, int dst, char *key, int n, int send)
+static char *TRACE_smpi_put_key(int src, int dst, int tag, char *key, int n, int send)
{
//get the dynar for src#dst
char aux[INSTR_DEFAULT_STR_SIZE];
- snprintf(aux, INSTR_DEFAULT_STR_SIZE, "%d#%d#%d", src, dst, send);
+ snprintf(aux, INSTR_DEFAULT_STR_SIZE, "%d#%d#%d#%d", src, dst, tag, send);
xbt_dynar_t d = static_cast<xbt_dynar_t>(xbt_dict_get_or_null(keys, aux));
if (d == nullptr) {
//generate the key
static unsigned long long counter = 0;
counter++;
- snprintf(key, n, "%d_%d_%llu", src, dst, counter);
+ snprintf(key, n, "%d_%d_%d_%llu", src, dst, tag, counter);
//push it
char *a = static_cast<char*> (xbt_strdup(key));
return key;
}
-static char *TRACE_smpi_get_key(int src, int dst, char *key, int n, int send)
+static char *TRACE_smpi_get_key(int src, int dst, int tag, char *key, int n, int send)
{
char aux[INSTR_DEFAULT_STR_SIZE];
- snprintf(aux, INSTR_DEFAULT_STR_SIZE, "%d#%d#%d", src, dst, send==1?0:1);
+ snprintf(aux, INSTR_DEFAULT_STR_SIZE, "%d#%d#%d#%d", src, dst, tag, send==1?0:1);
xbt_dynar_t d = static_cast<xbt_dynar_t>(xbt_dict_get_or_null(keys, aux));
// first posted
if(xbt_dynar_is_empty(d)){
- TRACE_smpi_put_key(src, dst, key, n, send);
+ TRACE_smpi_put_key(src, dst, tag, key, n, send);
return key;
}
new_pajePopState (SIMIX_get_clock(), container, type);
}
-void TRACE_smpi_send(int rank, int src, int dst, int size)
+void TRACE_smpi_send(int rank, int src, int dst, int tag, int size)
{
if (!TRACE_smpi_is_enabled())
return;
char key[INSTR_DEFAULT_STR_SIZE] = {0};
- TRACE_smpi_get_key(src, dst, key, INSTR_DEFAULT_STR_SIZE,1);
+ TRACE_smpi_get_key(src, dst, tag, key, INSTR_DEFAULT_STR_SIZE,1);
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(src, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_LINK", PJ_type_get_root());
- XBT_DEBUG("Send tracing from %d to %d, with key %s", src, dst, key);
+ XBT_DEBUG("Send tracing from %d to %d, tag %d, with key %s", src, dst, tag, key);
new_pajeStartLinkWithSize (SIMIX_get_clock(), PJ_container_get_root(), type, container, "PTP", key, size);
}
-void TRACE_smpi_recv(int rank, int src, int dst)
+void TRACE_smpi_recv(int rank, int src, int dst, int tag)
{
if (!TRACE_smpi_is_enabled())
return;
char key[INSTR_DEFAULT_STR_SIZE] = {0};
- TRACE_smpi_get_key(src, dst, key, INSTR_DEFAULT_STR_SIZE,0);
+ TRACE_smpi_get_key(src, dst, tag, key, INSTR_DEFAULT_STR_SIZE,0);
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(dst, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_LINK", PJ_type_get_root());
- XBT_DEBUG("Recv tracing from %d to %d, with key %s", src, dst, key);
+ XBT_DEBUG("Recv tracing from %d to %d, tag %d, with key %s", src, dst, tag, key);
new_pajeEndLink (SIMIX_get_clock(), PJ_container_get_root(), type, container, "PTP", key);
}
#define COLL_TAG_GATHERV -2223
#define COLL_TAG_BCAST -3334
#define COLL_TAG_ALLREDUCE -4445
+#define SMPI_RMA_TAG -1234
#define MPI_COMM_UNINITIALIZED ((MPI_Comm)-1)
XBT_PRIVATE void TRACE_smpi_release();
XBT_PRIVATE void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation, instr_extra_data extra);
XBT_PRIVATE void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation);
-XBT_PRIVATE void TRACE_smpi_send(int rank, int src, int dst, int size);
-XBT_PRIVATE void TRACE_smpi_recv(int rank, int src, int dst);
+XBT_PRIVATE void TRACE_smpi_send(int rank, int src, int dst, int tag, int size);
+XBT_PRIVATE void TRACE_smpi_recv(int rank, int src, int dst, int tag);
XBT_PRIVATE void TRACE_smpi_init(int rank);
XBT_PRIVATE void TRACE_smpi_finalize(int rank);
XBT_PRIVATE char *smpi_container(int rank, char *container, int n);
int rank = request->src;
if (TRACE_smpi_view_internals()) {
- TRACE_smpi_send(rank, rank, receiver,request->size);
+ TRACE_smpi_send(rank, rank, receiver, request->tag, request->size);
}
print_request("New send", request);
if (TRACE_smpi_view_internals() && ((req->flags & RECV) != 0)){
int rank = smpi_process_index();
int src_traced = (req->src == MPI_ANY_SOURCE ? req->real_src : req->src);
- TRACE_smpi_recv(rank, src_traced, rank);
+ TRACE_smpi_recv(rank, src_traced, rank,req->tag);
}
if(req->detached_sender != nullptr){
dt_size_send = smpi_datatype_size(datatype);
extra->send_size = count*dt_size_send;
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
- TRACE_smpi_send(rank, rank, dst_traced, count*smpi_datatype_size(datatype));
+ TRACE_smpi_send(rank, rank, dst_traced, tag, count*smpi_datatype_size(datatype));
*request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
dt_size_send = smpi_datatype_size(datatype);
extra->send_size = count*dt_size_send;
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
- TRACE_smpi_send(rank, rank, dst_traced, count*smpi_datatype_size(datatype));
+ TRACE_smpi_send(rank, rank, dst_traced, tag, count*smpi_datatype_size(datatype));
*request = smpi_mpi_issend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
if(status!=MPI_STATUS_IGNORE){
src_traced = smpi_group_index(smpi_comm_group(comm), status->MPI_SOURCE);
if (!TRACE_smpi_view_internals()) {
- TRACE_smpi_recv(rank, src_traced, rank);
+ TRACE_smpi_recv(rank, src_traced, rank, tag);
}
}
TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
extra->send_size = count*dt_size_send;
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
if (!TRACE_smpi_view_internals()) {
- TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype));
+ TRACE_smpi_send(rank, rank, dst_traced, tag,count*smpi_datatype_size(datatype));
}
smpi_mpi_send(buf, count, datatype, dst, tag, comm);
}
extra->send_size = count*dt_size_send;
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
- TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype));
+ TRACE_smpi_send(rank, rank, dst_traced, tag,count*smpi_datatype_size(datatype));
smpi_mpi_ssend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
extra->recv_size = recvcount*dt_size_recv;
TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
- TRACE_smpi_send(rank, rank, dst_traced,sendcount*smpi_datatype_size(sendtype));
+ TRACE_smpi_send(rank, rank, dst_traced, sendtag,sendcount*smpi_datatype_size(sendtype));
smpi_mpi_sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf,
recvcount, recvtype, src, recvtag, comm, status);
retval = MPI_SUCCESS;
TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
- TRACE_smpi_recv(rank, src_traced, rank);
+ TRACE_smpi_recv(rank, src_traced, rank, recvtag);
}
smpi_bench_begin();
int src_traced = (*request)->src;
int dst_traced = (*request)->dst;
+ int tag_traced= (*request)->tag;
MPI_Comm comm = (*request)->comm;
int is_wait_for_receive = (*request)->recv;
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
src_traced = (status!=MPI_STATUS_IGNORE) ?
smpi_group_rank(smpi_comm_group(comm), status->MPI_SOURCE) :
src_traced;
- TRACE_smpi_recv(rank, src_traced, dst_traced);
+ TRACE_smpi_recv(rank, src_traced, dst_traced, tag_traced);
}
}
smpi_bench_end();
//save requests information for tracing
int i;
- int *srcs = nullptr, *dsts = nullptr, *recvs = nullptr;
+ int *srcs = nullptr, *dsts = nullptr, *recvs = nullptr, *tags = nullptr;
MPI_Comm* comms = nullptr;
if(count>0){
srcs = xbt_new0(int, count);
dsts = xbt_new0(int, count);
recvs = xbt_new0(int, count);
+ tags = xbt_new0(int, count);
comms = xbt_new0(MPI_Comm, count);
}
for (i = 0; i < count; i++) {
srcs[i] = req->src;
dsts[i] = req->dst;
recvs[i] = req->recv;
+ tags[i] = req->tag;
comms[i] = req->comm;
}
}
if(srcs[*index]==MPI_ANY_SOURCE)
src_traced = (status!=MPI_STATUSES_IGNORE) ?
smpi_group_rank(smpi_comm_group(comms[*index]), status->MPI_SOURCE) : srcs[*index];
- TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
+ TRACE_smpi_recv(rank_traced, src_traced, dst_traced, tags[*index]);
}
TRACE_smpi_ptp_out(rank_traced, src_traced, dst_traced, __FUNCTION__);
}
xbt_free(srcs);
xbt_free(dsts);
xbt_free(recvs);
+ xbt_free(tags);
xbt_free(comms);
int *srcs = xbt_new0(int, count);
int *dsts = xbt_new0(int, count);
int *recvs = xbt_new0(int, count);
+ int *tags = xbt_new0(int, count);
int *valid = xbt_new0(int, count);
MPI_Comm *comms = xbt_new0(MPI_Comm, count);
srcs[i] = req->src;
dsts[i] = req->dst;
recvs[i] = req->recv;
+ tags[i] = req->tag;
comms[i] = req->comm;
valid[i]=1;;
}else{
if(src_traced==MPI_ANY_SOURCE)
src_traced = (status!=MPI_STATUSES_IGNORE) ?
smpi_group_rank(smpi_comm_group(comms[i]), status[i].MPI_SOURCE) : srcs[i];
- TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
+ TRACE_smpi_recv(rank_traced, src_traced, dst_traced,tags[i]);
}
}
}
xbt_free(dsts);
xbt_free(recvs);
xbt_free(valid);
+ xbt_free(tags);
xbt_free(comms);
smpi_bench_begin();
smpi_mpi_win_get_group(win, &group);
int dst_traced = smpi_group_index(group, target_rank);
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, nullptr);
- TRACE_smpi_send(rank, rank, dst_traced, origin_count*smpi_datatype_size(origin_datatype));
+ TRACE_smpi_send(rank, rank, dst_traced, SMPI_RMA_TAG, origin_count*smpi_datatype_size(origin_datatype));
retval = smpi_mpi_put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
target_datatype, win);
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));
+ TRACE_smpi_send(rank, rank, dst_traced, 0, size*smpi_datatype_size(MPI_CURRENT_TYPE));
}
smpi_mpi_send(nullptr, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD);
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));
+ TRACE_smpi_send(rank, rank, dst_traced, 0, size*smpi_datatype_size(MPI_CURRENT_TYPE));
}
request = smpi_mpi_isend(nullptr, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD);
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);
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);
}
for (i=0; i<count_requests;i++){
if (recvs_snd[i]!=-100)
- TRACE_smpi_recv(rank_traced, recvs_snd[i], recvs_rcv[i]);
+ TRACE_smpi_recv(rank_traced, recvs_snd[i], recvs_rcv[i],0);
}
xbt_free(recvs_rcv);
xbt_free(recvs_snd);
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_rma, smpi, "Logging specific to SMPI (RMA operations)");
-#define RMA_TAG -1234
-
msg_bar_t creation_bar = nullptr;
typedef struct s_smpi_mpi_win{
if(target_rank != smpi_comm_rank(win->comm)){
//prepare send_request
MPI_Request sreq = smpi_rma_send_init(origin_addr, origin_count, origin_datatype, smpi_process_index(),
- smpi_group_index(smpi_comm_group(win->comm),target_rank), RMA_TAG+1, win->comm, MPI_OP_NULL);
+ smpi_group_index(smpi_comm_group(win->comm),target_rank), SMPI_RMA_TAG+1, win->comm, MPI_OP_NULL);
//prepare receiver request
MPI_Request rreq = smpi_rma_recv_init(recv_addr, target_count, target_datatype, smpi_process_index(),
- smpi_group_index(smpi_comm_group(win->comm),target_rank), RMA_TAG+1, recv_win->comm, MPI_OP_NULL);
+ smpi_group_index(smpi_comm_group(win->comm),target_rank), SMPI_RMA_TAG+1, recv_win->comm, MPI_OP_NULL);
//push request to receiver's win
recv_win->requests->push_back(rreq);
if(target_rank != smpi_comm_rank(win->comm)){
//prepare send_request
MPI_Request sreq = smpi_rma_send_init(send_addr, target_count, target_datatype,
- smpi_group_index(smpi_comm_group(win->comm),target_rank), smpi_process_index(), RMA_TAG+2, send_win->comm,
+ smpi_group_index(smpi_comm_group(win->comm),target_rank), smpi_process_index(), SMPI_RMA_TAG+2, send_win->comm,
MPI_OP_NULL);
//prepare receiver request
MPI_Request rreq = smpi_rma_recv_init(origin_addr, origin_count, origin_datatype,
- smpi_group_index(smpi_comm_group(win->comm),target_rank), smpi_process_index(), RMA_TAG+2, win->comm,
+ smpi_group_index(smpi_comm_group(win->comm),target_rank), smpi_process_index(), SMPI_RMA_TAG+2, win->comm,
MPI_OP_NULL);
//start the send, with another process than us as sender.
//prepare send_request
MPI_Request sreq = smpi_rma_send_init(origin_addr, origin_count, origin_datatype,
- smpi_process_index(), smpi_group_index(smpi_comm_group(win->comm),target_rank), RMA_TAG+3, win->comm, op);
+ smpi_process_index(), smpi_group_index(smpi_comm_group(win->comm),target_rank), SMPI_RMA_TAG+3, win->comm, op);
//prepare receiver request
MPI_Request rreq = smpi_rma_recv_init(recv_addr, target_count, target_datatype,
- smpi_process_index(), smpi_group_index(smpi_comm_group(win->comm),target_rank), RMA_TAG+3, recv_win->comm, op);
+ smpi_process_index(), smpi_group_index(smpi_comm_group(win->comm),target_rank), SMPI_RMA_TAG+3, recv_win->comm, op);
//push request to receiver's win
recv_win->requests->push_back(rreq);
//start send
while(j!=size){
int src=smpi_group_index(group,j);
if(src!=smpi_process_index()){
- reqs[i]=smpi_irecv_init(nullptr, 0, MPI_CHAR, src,RMA_TAG+4, MPI_COMM_WORLD);
+ reqs[i]=smpi_irecv_init(nullptr, 0, MPI_CHAR, src,SMPI_RMA_TAG+4, MPI_COMM_WORLD);
i++;
}
j++;
while(j!=size){
int dst=smpi_group_index(group,j);
if(dst!=smpi_process_index()){
- reqs[i]=smpi_mpi_send_init(nullptr, 0, MPI_CHAR, dst, RMA_TAG+4, MPI_COMM_WORLD);
+ reqs[i]=smpi_mpi_send_init(nullptr, 0, MPI_CHAR, dst, SMPI_RMA_TAG+4, MPI_COMM_WORLD);
i++;
}
j++;
while(j!=size){
int dst=smpi_group_index(win->group,j);
if(dst!=smpi_process_index()){
- reqs[i]=smpi_mpi_send_init(nullptr, 0, MPI_CHAR, dst, RMA_TAG+5, MPI_COMM_WORLD);
+ reqs[i]=smpi_mpi_send_init(nullptr, 0, MPI_CHAR, dst, SMPI_RMA_TAG+5, MPI_COMM_WORLD);
i++;
}
j++;
while(j!=size){
int src=smpi_group_index(win->group,j);
if(src!=smpi_process_index()){
- reqs[i]=smpi_irecv_init(nullptr, 0, MPI_CHAR, src,RMA_TAG+5, MPI_COMM_WORLD);
+ reqs[i]=smpi_irecv_init(nullptr, 0, MPI_CHAR, src,SMPI_RMA_TAG+5, MPI_COMM_WORLD);
i++;
}
j++;