XBT_PRIVATE void TRACE_internal_smpi_set_category(const char* category);
XBT_PRIVATE const char* TRACE_internal_smpi_get_category();
-XBT_PRIVATE void TRACE_smpi_collective_in(int rank, const char* operation, instr_extra_data extra);
-XBT_PRIVATE void TRACE_smpi_collective_out(int rank);
XBT_PRIVATE void TRACE_smpi_computing_init(int rank);
XBT_PRIVATE void TRACE_smpi_computing_out(int rank);
XBT_PRIVATE void TRACE_smpi_computing_in(int rank, instr_extra_data extra);
XBT_PRIVATE void TRACE_smpi_testing_in(int rank, instr_extra_data extra);
XBT_PRIVATE void TRACE_smpi_alloc();
XBT_PRIVATE void TRACE_smpi_release();
-XBT_PRIVATE void TRACE_smpi_ptp_in(int rank, const char* operation, instr_extra_data extra);
-XBT_PRIVATE void TRACE_smpi_ptp_out(int rank);
+XBT_PRIVATE void TRACE_smpi_comm_in(int rank, const char* operation, instr_extra_data extra);
+XBT_PRIVATE void TRACE_smpi_comm_out(int rank);
XBT_PRIVATE void TRACE_smpi_send(int rank, int src, int dst, int tag, int size);
XBT_PRIVATE void TRACE_smpi_recv(int src, int dst, int tag);
XBT_PRIVATE void TRACE_smpi_init(int rank);
TRACE_smpi_computing_init(rank);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_INIT;
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_out(rank);
smpi_bench_begin();
}
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, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
smpi_process()->finalize();
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
TRACE_smpi_finalize(smpi_process()->index());
return MPI_SUCCESS;
}
extra->root = root_traced;
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
if (comm->size() > 1)
simgrid::smpi::Colls::bcast(buf, count, datatype, root, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
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, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Colls::barrier(comm);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->datatype2 = encode_datatype(recvtype);
extra->recv_size = (comm->rank() != root || recvtype->is_basic()) ? recvcount : recvcount * recvtype->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Colls::gather(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, root, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->recvcounts[i] = recvcounts[i] * dt_size_recv;
}
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
retval = simgrid::smpi::Colls::gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts, displs, recvtype, root, comm);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->datatype2 = encode_datatype(recvtype);
extra->recv_size = recvtype->is_basic() ? recvcount : recvcount * recvtype->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Colls::allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
for (int i = 0; i < extra->num_processes; i++) // copy data to avoid bad free
extra->recvcounts[i] = recvcounts[i] * dt_size_recv;
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Colls::allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->datatype2 = encode_datatype(recvtype);
extra->recv_size = recvtype->is_basic() ? recvcount : recvcount * recvtype->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Colls::scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->sendcounts[i] = sendcounts[i] * dt_size_send;
}
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
retval = simgrid::smpi::Colls::scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Colls::reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Colls::allreduce(sendtmpbuf, recvbuf, count, datatype, op, comm);
xbt_free(sendtmpbuf);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
retval = simgrid::smpi::Colls::scan(sendbuf, recvbuf, count, datatype, op, comm);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
sendtmpbuf = static_cast<void*>(xbt_malloc(count * datatype->size()));
memcpy(sendtmpbuf, recvbuf, count * datatype->size());
}
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
retval = simgrid::smpi::Colls::exscan(sendtmpbuf, recvbuf, count, datatype, op, comm);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
if (sendbuf == MPI_IN_PLACE)
xbt_free(sendtmpbuf);
}
memcpy(sendtmpbuf, recvbuf, totalcount * datatype->size());
}
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Colls::reduce_scatter(sendtmpbuf, recvbuf, recvcounts, datatype, op, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
if (sendbuf == MPI_IN_PLACE)
xbt_free(sendtmpbuf);
memcpy(sendtmpbuf, recvbuf, recvcount * count * datatype->size());
}
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
int* recvcounts = new int[count];
for (int i = 0; i < count; i++)
delete[] recvcounts;
retval = MPI_SUCCESS;
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
if (sendbuf == MPI_IN_PLACE)
xbt_free(sendtmpbuf);
extra->datatype2 = encode_datatype(recvtype);
extra->recv_size = recvtype->is_basic() ? recvcount : recvcount * recvtype->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
retval = simgrid::smpi::Colls::alltoall(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, comm);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
if (sendbuf == MPI_IN_PLACE)
xbt_free(sendtmpbuf);
extra->sendcounts[i] = sendtmpcounts[i] * dt_size_send;
}
extra->num_processes = size;
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
retval = simgrid::smpi::Colls::alltoallv(sendtmpbuf, sendtmpcounts, sendtmpdisps, sendtmptype, recvbuf, recvcounts,
recvdisps, recvtype, comm);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
if (sendbuf == MPI_IN_PLACE) {
xbt_free(sendtmpbuf);
extra->dst = rank;
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
*request = simgrid::smpi::Request::irecv(buf, count, datatype, src, tag, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->dst = dst_traced;
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
TRACE_smpi_send(rank, rank, dst_traced, tag, count*datatype->size());
*request = simgrid::smpi::Request::isend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->dst = dst_traced;
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
TRACE_smpi_send(rank, rank, dst_traced, tag, count*datatype->size());
*request = simgrid::smpi::Request::issend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->dst = rank;
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Request::recv(buf, count, datatype, src, tag, comm, status);
retval = MPI_SUCCESS;
TRACE_smpi_recv(src_traced, rank, tag);
}
}
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->dst = dst_traced;
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
if (not TRACE_smpi_view_internals()) {
TRACE_smpi_send(rank, rank, dst_traced, tag,count*datatype->size());
}
simgrid::smpi::Request::send(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->datatype1 = encode_datatype(datatype);
extra->send_size = datatype->is_basic() ? count : count * datatype->size();
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
TRACE_smpi_send(rank, rank, dst_traced, tag, count * datatype->size());
simgrid::smpi::Request::ssend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
extra->datatype2 = encode_datatype(recvtype);
extra->recv_size = recvtype->is_basic() ? recvcount : recvcount * recvtype->size();
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
TRACE_smpi_send(rank, rank, dst_traced, sendtag, sendcount * sendtype->size());
simgrid::smpi::Request::sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf, recvcount, recvtype, src,
recvtag, comm, status);
retval = MPI_SUCCESS;
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
TRACE_smpi_recv(src_traced, rank, recvtag);
}
int is_wait_for_receive = ((*request)->flags() & RECV);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_WAIT;
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
simgrid::smpi::Request::wait(request, status);
retval = MPI_SUCCESS;
//the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
if (is_wait_for_receive) {
if(src_traced==MPI_ANY_SOURCE)
src_traced = (status != MPI_STATUS_IGNORE) ? comm->group()->rank(status->MPI_SOURCE) : src_traced;
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_WAITANY;
extra->send_size=count;
- TRACE_smpi_ptp_in(rank_traced, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank_traced, __FUNCTION__, extra);
*index = simgrid::smpi::Request::waitany(count, requests, status);
: savedvals[*index].src;
TRACE_smpi_recv(src_traced, dst_traced, savedvals[*index].tag);
}
- TRACE_smpi_ptp_out(rank_traced);
+ TRACE_smpi_comm_out(rank_traced);
}
xbt_free(savedvals);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_WAITALL;
extra->send_size=count;
- TRACE_smpi_ptp_in(rank_traced, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank_traced, __FUNCTION__, extra);
int retval = simgrid::smpi::Request::waitall(count, requests, status);
}
}
}
- TRACE_smpi_ptp_out(rank_traced);
+ TRACE_smpi_comm_out(rank_traced);
xbt_free(savedvals);
smpi_bench_begin();
retval = MPI_ERR_WIN;
} else {
int rank = smpi_process()->index();
- TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->fence(assert);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
int rank = smpi_process()->index();
MPI_Group group;
win->get_group(&group);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
target_datatype);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
int rank = smpi_process()->index();
MPI_Group group;
win->get_group(&group);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
target_datatype, request);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
MPI_Group group;
win->get_group(&group);
int dst_traced = group->index(target_rank);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
TRACE_smpi_send(rank, rank, dst_traced, SMPI_RMA_TAG, origin_count*origin_datatype->size());
retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
target_datatype);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
MPI_Group group;
win->get_group(&group);
int dst_traced = group->index(target_rank);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
TRACE_smpi_send(rank, rank, dst_traced, SMPI_RMA_TAG, origin_count*origin_datatype->size());
retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
target_datatype, request);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
int rank = smpi_process()->index();
MPI_Group group;
win->get_group(&group);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
target_datatype, op);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
int rank = smpi_process()->index();
MPI_Group group;
win->get_group(&group);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
target_datatype, op, request);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
int rank = smpi_process()->index();
MPI_Group group;
win->get_group(&group);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
result_count, result_datatype, target_rank, target_disp,
target_count, target_datatype, op);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
int rank = smpi_process()->index();
MPI_Group group;
win->get_group(&group);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
result_count, result_datatype, target_rank, target_disp,
target_count, target_datatype, op, request);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
int rank = smpi_process()->index();
MPI_Group group;
win->get_group(&group);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->compare_and_swap(origin_addr, compare_addr, result_addr, datatype, target_rank, target_disp);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
retval = MPI_ERR_GROUP;
} else {
int rank = smpi_process()->index();
- TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->post(group,assert);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
retval = MPI_ERR_GROUP;
} else {
int rank = smpi_process()->index();
- TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->start(group,assert);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
retval = MPI_ERR_WIN;
} else {
int rank = smpi_process()->index();
- TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->complete();
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
retval = MPI_ERR_WIN;
} else {
int rank = smpi_process()->index();
- TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, nullptr);
retval = win->wait();
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
}
smpi_bench_begin();
return retval;
retval = MPI_SUCCESS;
} else {
int myrank = smpi_process()->index();
- TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(myrank, __FUNCTION__, nullptr);
retval = win->lock(lock_type,rank,assert);
- TRACE_smpi_collective_out(myrank);
+ TRACE_smpi_comm_out(myrank);
}
smpi_bench_begin();
return retval;
retval = MPI_SUCCESS;
} else {
int myrank = smpi_process()->index();
- TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(myrank, __FUNCTION__, nullptr);
retval = win->unlock(rank);
- TRACE_smpi_collective_out(myrank);
+ TRACE_smpi_comm_out(myrank);
}
smpi_bench_begin();
return retval;
retval = MPI_ERR_WIN;
} else {
int myrank = smpi_process()->index();
- TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(myrank, __FUNCTION__, nullptr);
retval = win->lock_all(assert);
- TRACE_smpi_collective_out(myrank);
+ TRACE_smpi_comm_out(myrank);
}
smpi_bench_begin();
return retval;
retval = MPI_ERR_WIN;
} else {
int myrank = smpi_process()->index();
- TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(myrank, __FUNCTION__, nullptr);
retval = win->unlock_all();
- TRACE_smpi_collective_out(myrank);
+ TRACE_smpi_comm_out(myrank);
}
smpi_bench_begin();
return retval;
retval = MPI_SUCCESS;
} else {
int myrank = smpi_process()->index();
- TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(myrank, __FUNCTION__, nullptr);
retval = win->flush(rank);
- TRACE_smpi_collective_out(myrank);
+ TRACE_smpi_comm_out(myrank);
}
smpi_bench_begin();
return retval;
retval = MPI_SUCCESS;
} else {
int myrank = smpi_process()->index();
- TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(myrank, __FUNCTION__, nullptr);
retval = win->flush_local(rank);
- TRACE_smpi_collective_out(myrank);
+ TRACE_smpi_comm_out(myrank);
}
smpi_bench_begin();
return retval;
retval = MPI_ERR_WIN;
} else {
int myrank = smpi_process()->index();
- TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(myrank, __FUNCTION__, nullptr);
retval = win->flush_all();
- TRACE_smpi_collective_out(myrank);
+ TRACE_smpi_comm_out(myrank);
}
smpi_bench_begin();
return retval;
retval = MPI_ERR_WIN;
} else {
int myrank = smpi_process()->index();
- TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
+ TRACE_smpi_comm_in(myrank, __FUNCTION__, nullptr);
retval = win->flush_local_all();
- TRACE_smpi_collective_out(myrank);
+ TRACE_smpi_comm_out(myrank);
}
smpi_bench_begin();
return retval;
delete container;
}
-void TRACE_smpi_collective_in(int rank, const char *operation, instr_extra_data extra)
-{
- if (not TRACE_smpi_is_enabled()) {
- cleanup_extra_data(extra);
- return;
- }
-
- simgrid::instr::StateType* state = simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE");
- const char *color = instr_find_color (operation);
- state->addEntityValue(operation, color);
- state->pushEvent(operation, static_cast<void*>(extra));
-}
-
-void TRACE_smpi_collective_out(int rank)
-{
- if (TRACE_smpi_is_enabled())
- simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE")->popEvent();
-}
-
void TRACE_smpi_computing_init(int rank)
{
//first use, initialize the color in the trace
simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE")->popEvent();
}
-void TRACE_smpi_ptp_in(int rank, const char *operation, instr_extra_data extra)
+void TRACE_smpi_comm_in(int rank, const char* operation, instr_extra_data extra)
{
if (not TRACE_smpi_is_enabled()) {
cleanup_extra_data(extra);
state->pushEvent(operation, static_cast<void*>(extra));
}
-void TRACE_smpi_ptp_out(int rank)
+void TRACE_smpi_comm_out(int rank)
{
if (TRACE_smpi_is_enabled())
simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE")->popEvent();
extra->src = rank;
extra->dst = dst_traced;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
if (not TRACE_smpi_view_internals())
TRACE_smpi_send(rank, rank, dst_traced, 0, size*MPI_CURRENT_TYPE->size());
log_timed_action (action, clock);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
}
static void action_Isend(const char *const *action)
extra->src = rank;
extra->dst = dst_traced;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
if (not TRACE_smpi_view_internals())
TRACE_smpi_send(rank, rank, dst_traced, 0, size*MPI_CURRENT_TYPE->size());
MPI_Request request = Request::isend(nullptr, size, MPI_CURRENT_TYPE, to, 0, MPI_COMM_WORLD);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
get_reqq_self()->push_back(request);
extra->src = src_traced;
extra->dst = rank;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
//unknown size from the receiver point of view
if(size<=0.0){
Request::recv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
if (not TRACE_smpi_view_internals()) {
TRACE_smpi_recv(src_traced, rank, 0);
}
extra->src = src_traced;
extra->dst = rank;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
MPI_Status status;
//unknow size from the receiver pov
if(size<=0.0){
MPI_Request request = Request::irecv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
get_reqq_self()->push_back(request);
log_timed_action (action, clock);
int is_wait_for_receive = (request->flags() & RECV);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_WAIT;
- TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
Request::wait(&request, &status);
- TRACE_smpi_ptp_out(rank);
+ TRACE_smpi_comm_out(rank);
if (is_wait_for_receive)
TRACE_smpi_recv(src_traced, dst_traced, 0);
log_timed_action (action, clock);
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, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank_traced, __FUNCTION__, extra);
int recvs_snd[count_requests];
int recvs_rcv[count_requests];
for (unsigned int i = 0; i < count_requests; i++) {
if (recvs_snd[i]!=-100)
TRACE_smpi_recv(recvs_snd[i], recvs_rcv[i],0);
}
- TRACE_smpi_ptp_out(rank_traced);
+ TRACE_smpi_comm_out(rank_traced);
}
log_timed_action (action, clock);
}
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, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
Colls::barrier(MPI_COMM_WORLD);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
extra->send_size = size;
extra->root = root_traced;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
- TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
Colls::bcast(sendbuf, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
extra->root = root_traced;
- TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
Colls::reduce(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, root, MPI_COMM_WORLD);
smpi_execute_flops(comp_size);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
extra->send_size = comm_size;
extra->comp_size = comp_size;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
- TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
Colls::allreduce(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD);
smpi_execute_flops(comp_size);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2);
- TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
Colls::alltoall(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2);
- TRACE_smpi_collective_in(smpi_process()->index(), __FUNCTION__, extra);
+ TRACE_smpi_comm_in(smpi_process()->index(), __FUNCTION__, extra);
Colls::gather(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD);
- TRACE_smpi_collective_out(smpi_process()->index());
+ TRACE_smpi_comm_out(smpi_process()->index());
log_timed_action (action, clock);
}
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2);
- TRACE_smpi_collective_in(smpi_process()->index(), __FUNCTION__, extra);
+ TRACE_smpi_comm_in(smpi_process()->index(), __FUNCTION__, extra);
Colls::gatherv(send, send_size, MPI_CURRENT_TYPE, recv, recvcounts, disps, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD);
- TRACE_smpi_collective_out(smpi_process()->index());
+ TRACE_smpi_comm_out(smpi_process()->index());
log_timed_action (action, clock);
}
extra->comp_size = comp_size;
extra->num_processes = comm_size;
- TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
void *recvbuf = smpi_get_tmp_recvbuffer(size* MPI_CURRENT_TYPE->size());
Colls::reduce_scatter(sendbuf, recvbuf, recvcounts, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD);
smpi_execute_flops(comp_size);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2);
extra->num_processes = MPI_COMM_WORLD->size();
- TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
Colls::allgather(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcount, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2);
extra->num_processes = comm_size;
- TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
Colls::allgatherv(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2,
MPI_COMM_WORLD);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE);
extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2);
- TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
+ TRACE_smpi_comm_in(rank, __FUNCTION__, extra);
Colls::alltoallv(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE,recvbuf, recvcounts, recvdisps,
MPI_CURRENT_TYPE, MPI_COMM_WORLD);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_out(rank);
log_timed_action (action, clock);
}
TRACE_smpi_computing_init(rank);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_INIT;
- TRACE_smpi_collective_in(rank, "smpi_replay_run_init", extra);
- TRACE_smpi_collective_out(rank);
+ TRACE_smpi_comm_in(rank, "smpi_replay_run_init", extra);
+ TRACE_smpi_comm_out(rank);
xbt_replay_action_register("init", simgrid::smpi::action_init);
xbt_replay_action_register("finalize", simgrid::smpi::action_finalize);
xbt_replay_action_register("comm_size", simgrid::smpi::action_comm_size);
instr_extra_data extra_fin = xbt_new0(s_instr_extra_data_t,1);
extra_fin->type = TRACING_FINALIZE;
- TRACE_smpi_collective_in(smpi_process()->index(), "smpi_replay_run_finalize", extra_fin);
+ TRACE_smpi_comm_in(smpi_process()->index(), "smpi_replay_run_finalize", extra_fin);
smpi_process()->finalize();
- TRACE_smpi_collective_out(smpi_process()->index());
+ TRACE_smpi_comm_out(smpi_process()->index());
TRACE_smpi_finalize(smpi_process()->index());
}