return MPI_SUCCESS;
}else{
group->use();
- *newcomm = new simgrid::SMPI::Comm(group, nullptr);
+ *newcomm = new simgrid::smpi::Comm(group, nullptr);
return MPI_SUCCESS;
}
}
} else if (dst == MPI_PROC_NULL) {
retval = MPI_SUCCESS;
} else {
- *request = smpi_mpi_send_init(buf, count, datatype, dst, tag, comm);
+ *request = Request::send_init(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
} else if (src == MPI_PROC_NULL) {
retval = MPI_SUCCESS;
} else {
- *request = smpi_mpi_recv_init(buf, count, datatype, src, tag, comm);
+ *request = Request::recv_init(buf, count, datatype, src, tag, comm);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
} else if (dst == MPI_PROC_NULL) {
retval = MPI_SUCCESS;
} else {
- *request = smpi_mpi_ssend_init(buf, count, datatype, dst, tag, comm);
+ *request = Request::ssend_init(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
if (request == nullptr || *request == MPI_REQUEST_NULL) {
retval = MPI_ERR_REQUEST;
} else {
- smpi_mpi_start(*request);
+ (*request)->start();
retval = MPI_SUCCESS;
}
smpi_bench_begin();
}
}
if(retval != MPI_ERR_REQUEST) {
- smpi_mpi_startall(count, requests);
+ Request::startall(count, requests);
}
}
smpi_bench_begin();
if (*request == MPI_REQUEST_NULL) {
retval = MPI_ERR_ARG;
} else {
- smpi_mpi_request_free(request);
+ Request::unuse(request);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
extra->send_size = count*dt_size_send;
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
- *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);
+ *request = Request::irecv(buf, count, datatype, src, tag, comm);
retval = MPI_SUCCESS;
TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
- (*request)->recv = 1;
}
smpi_bench_begin();
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
TRACE_smpi_send(rank, rank, dst_traced, tag, count*smpi_datatype_size(datatype));
- *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
+ *request = Request::isend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
- (*request)->send = 1;
}
smpi_bench_begin();
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
TRACE_smpi_send(rank, rank, dst_traced, tag, count*smpi_datatype_size(datatype));
- *request = smpi_mpi_issend(buf, count, datatype, dst, tag, comm);
+ *request = Request::issend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
- (*request)->send = 1;
}
smpi_bench_begin();
extra->send_size = count * dt_size_send;
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
- smpi_mpi_recv(buf, count, datatype, src, tag, comm, status);
+ Request::recv(buf, count, datatype, src, tag, comm, status);
retval = MPI_SUCCESS;
// the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
TRACE_smpi_send(rank, rank, dst_traced, tag,count*smpi_datatype_size(datatype));
}
- smpi_mpi_send(buf, count, datatype, dst, tag, comm);
+ Request::send(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
TRACE_smpi_send(rank, rank, dst_traced, tag,count*smpi_datatype_size(datatype));
- smpi_mpi_ssend(buf, count, datatype, dst, tag, comm);
+ Request::ssend(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
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,
+ Request::sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf, recvcount, recvtype, src, recvtag, comm,
status);
retval = MPI_SUCCESS;
smpi_empty_status(status);
retval = MPI_SUCCESS;
} else {
- int rank = ((*request)->comm != MPI_COMM_NULL) ? smpi_process_index() : -1;
+ int rank = ((*request)->comm() != MPI_COMM_NULL) ? smpi_process_index() : -1;
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);
+ *flag = Request::test(request,status);
TRACE_smpi_testing_out(rank);
retval = MPI_SUCCESS;
if (index == nullptr || flag == nullptr) {
retval = MPI_ERR_ARG;
} else {
- *flag = smpi_mpi_testany(count, requests, index, status);
+ *flag = Request::testany(count, requests, index, status);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
if (flag == nullptr) {
retval = MPI_ERR_ARG;
} else {
- *flag = smpi_mpi_testall(count, requests, statuses);
+ *flag = Request::testall(count, requests, statuses);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
status->MPI_SOURCE = MPI_PROC_NULL;
retval = MPI_SUCCESS;
} else {
- smpi_mpi_probe(source, tag, comm, status);
+ Request::probe(source, tag, comm, status);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
status->MPI_SOURCE = MPI_PROC_NULL;
retval = MPI_SUCCESS;
} else {
- smpi_mpi_iprobe(source, tag, comm, flag, status);
+ Request::iprobe(source, tag, comm, flag, status);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
retval = MPI_SUCCESS;
} else {
- int rank = (request!=nullptr && (*request)->comm != MPI_COMM_NULL) ? smpi_process_index() : -1;
+ int rank = (request!=nullptr && (*request)->comm() != MPI_COMM_NULL) ? smpi_process_index() : -1;
- 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;
+ 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)->flags() & RECV);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_WAIT;
TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
- smpi_mpi_wait(request, status);
+ Request::wait(request, status);
retval = MPI_SUCCESS;
//the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
for (int i = 0; i < count; i++) {
MPI_Request req = requests[i]; //already received requests are no longer valid
if (req) {
- savedvals[i]=(savedvalstype){req->src, req->dst, req->recv, req->tag, req->comm};
+ savedvals[i]=(savedvalstype){req->src(), req->dst(), (req->flags() & RECV), req->tag(), req->comm()};
}
}
int rank_traced = smpi_process_index();
extra->send_size=count;
TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra);
- *index = smpi_mpi_waitany(count, requests, status);
+ *index = Request::waitany(count, requests, status);
if(*index!=MPI_UNDEFINED){
int src_traced = savedvals[*index].src;
for (int i = 0; i < count; i++) {
MPI_Request req = requests[i];
if(req!=MPI_REQUEST_NULL){
- savedvals[i]=(savedvalstype){req->src, req->dst, req->recv, req->tag, 1, req->comm};
+ savedvals[i]=(savedvalstype){req->src(), req->dst(), (req->flags() & RECV), req->tag(), 1, req->comm()};
}else{
savedvals[i].valid=0;
}
extra->send_size=count;
TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra);
- int retval = smpi_mpi_waitall(count, requests, status);
+ int retval =Request::waitall(count, requests, status);
for (int i = 0; i < count; i++) {
if(savedvals[i].valid){
if (outcount == nullptr) {
retval = MPI_ERR_ARG;
} else {
- *outcount = smpi_mpi_waitsome(incount, requests, indices, status);
+ *outcount = Request::waitsome(incount, requests, indices, status);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
if (outcount == nullptr) {
retval = MPI_ERR_ARG;
} else {
- *outcount = smpi_mpi_testsome(incount, requests, indices, status);
+ *outcount = Request::testsome(incount, requests, indices, status);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
} else if (ndims < 0 || (ndims > 0 && (dims == nullptr || periodic == nullptr)) || comm_cart == nullptr) {
return MPI_ERR_ARG;
} else{
- return smpi_mpi_cart_create(comm_old, ndims, dims, periodic, reorder, comm_cart);
+ new simgrid::smpi::Cart(comm_old, ndims, dims, periodic, reorder, comm_cart);
+ return MPI_SUCCESS;
}
}
if (coords == nullptr) {
return MPI_ERR_ARG;
}
- return smpi_mpi_cart_rank(comm, coords, rank);
+ simgrid::smpi::Cart* topo = static_cast<simgrid::smpi::Cart*>(comm->topo());
+ if (topo==nullptr) {
+ return MPI_ERR_ARG;
+ }
+ return topo->rank(coords, rank);
}
int PMPI_Cart_shift(MPI_Comm comm, int direction, int displ, int* source, int* dest) {
if (source == nullptr || dest == nullptr || direction < 0 ) {
return MPI_ERR_ARG;
}
- return smpi_mpi_cart_shift(comm, direction, displ, source, dest);
+ simgrid::smpi::Cart* topo = static_cast<simgrid::smpi::Cart*>(comm->topo());
+ if (topo==nullptr) {
+ return MPI_ERR_ARG;
+ }
+ return topo->shift(direction, displ, source, dest);
}
int PMPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int* coords) {
if(coords == nullptr) {
return MPI_ERR_ARG;
}
- return smpi_mpi_cart_coords(comm, rank, maxdims, coords);
+ simgrid::smpi::Cart* topo = static_cast<simgrid::smpi::Cart*>(comm->topo());
+ if (topo==nullptr) {
+ return MPI_ERR_ARG;
+ }
+ return topo->coords(rank, maxdims, coords);
}
int PMPI_Cart_get(MPI_Comm comm, int maxdims, int* dims, int* periods, int* coords) {
if(maxdims <= 0 || dims == nullptr || periods == nullptr || coords == nullptr) {
return MPI_ERR_ARG;
}
- return smpi_mpi_cart_get(comm, maxdims, dims, periods, coords);
+ simgrid::smpi::Cart* topo = static_cast<simgrid::smpi::Cart*>(comm->topo());
+ if (topo==nullptr) {
+ return MPI_ERR_ARG;
+ }
+ return topo->get(maxdims, dims, periods, coords);
}
int PMPI_Cartdim_get(MPI_Comm comm, int* ndims) {
if (ndims == nullptr) {
return MPI_ERR_ARG;
}
- return smpi_mpi_cartdim_get(comm, ndims);
+ simgrid::smpi::Cart* topo = static_cast<simgrid::smpi::Cart*>(comm->topo());
+ if (topo==nullptr) {
+ return MPI_ERR_ARG;
+ }
+ return topo->dim_get(ndims);
}
int PMPI_Dims_create(int nnodes, int ndims, int* dims) {
if (ndims < 1 || nnodes < 1) {
return MPI_ERR_DIMS;
}
-
- return smpi_mpi_dims_create(nnodes, ndims, dims);
+ return simgrid::smpi::Dims_create(nnodes, ndims, dims);
}
int PMPI_Cart_sub(MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new) {
if (comm_new == nullptr) {
return MPI_ERR_ARG;
}
- return smpi_mpi_cart_sub(comm, remain_dims, comm_new);
+ simgrid::smpi::Cart* topo = static_cast<simgrid::smpi::Cart*>(comm->topo());
+ if (topo==nullptr) {
+ return MPI_ERR_ARG;
+ }
+ simgrid::smpi::Cart* cart = topo->sub(remain_dims, comm_new);
+ if(cart==nullptr)
+ return MPI_ERR_ARG;
+ return MPI_SUCCESS;
}
int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){
}else if ((base == nullptr && size != 0) || disp_unit <= 0 || size < 0 ){
retval= MPI_ERR_OTHER;
}else{
- *win = smpi_mpi_win_create( base, size, disp_unit, info, comm);
+ *win = new simgrid::smpi::Win( base, size, disp_unit, info, comm);
retval = MPI_SUCCESS;
}
smpi_bench_begin();
if (win == nullptr || *win == MPI_WIN_NULL) {
retval = MPI_ERR_WIN;
}else{
- retval=smpi_mpi_win_free(win);
+ delete(*win);
+ retval=MPI_SUCCESS;
}
smpi_bench_begin();
return retval;
} else if (name == nullptr) {
return MPI_ERR_ARG;
} else {
- smpi_mpi_win_set_name(win, name);
+ win->set_name(name);
return MPI_SUCCESS;
}
}
} else if (name == nullptr) {
return MPI_ERR_ARG;
} else {
- smpi_mpi_win_get_name(win, name, len);
+ win->get_name(name, len);
return MPI_SUCCESS;
}
}
if (win == MPI_WIN_NULL) {
return MPI_ERR_WIN;
}else {
- smpi_mpi_win_get_group(win, group);
+ win->get_group(group);
(*group)->use();
return MPI_SUCCESS;
}
} else {
int rank = smpi_process_index();
TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
- retval = smpi_mpi_win_fence(assert, win);
+ retval = win->fence(assert);
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
}
smpi_bench_begin();
} else {
int rank = smpi_process_index();
MPI_Group group;
- smpi_mpi_win_get_group(win, &group);
+ win->get_group(&group);
int src_traced = group->index(target_rank);
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
- retval = smpi_mpi_get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
- target_datatype, win);
+ retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
+ target_datatype);
TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
}
} else {
int rank = smpi_process_index();
MPI_Group group;
- smpi_mpi_win_get_group(win, &group);
+ win->get_group(&group);
int dst_traced = group->index(target_rank);
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, nullptr);
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);
+ retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
+ target_datatype);
TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
}
} else {
int rank = smpi_process_index();
MPI_Group group;
- smpi_mpi_win_get_group(win, &group);
+ win->get_group(&group);
int src_traced = group->index(target_rank);
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
- retval = smpi_mpi_accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
- target_datatype, op, win);
+ retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
+ target_datatype, op);
TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
}
} else {
int rank = smpi_process_index();
TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
- retval = smpi_mpi_win_post(group,assert,win);
+ retval = win->post(group,assert);
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
}
smpi_bench_begin();
} else {
int rank = smpi_process_index();
TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
- retval = smpi_mpi_win_start(group,assert,win);
+ retval = win->start(group,assert);
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
}
smpi_bench_begin();
int rank = smpi_process_index();
TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
- retval = smpi_mpi_win_complete(win);
+ retval = win->complete();
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
}
int rank = smpi_process_index();
TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
- retval = smpi_mpi_win_wait(win);
+ retval = win->wait();
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
}
