* under the terms of the license (GNU LGPL) which comes with this package. */
#include "private.h"
-#include "xbt/replay.h"
+#include "xbt/replay.hpp"
#include <unordered_map>
#include <vector>
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, " ");
- XBT_VERB("%s %f", name, smpi_process_simulated_elapsed()-clock);
+ XBT_VERB("%s %f", name, smpi_process()->simulated_elapsed()-clock);
xbt_free(name);
}
}
static std::vector<MPI_Request>* get_reqq_self()
{
- return reqq.at(smpi_process_index());
+ return reqq.at(smpi_process()->index());
}
static void set_reqq_self(std::vector<MPI_Request> *mpi_request)
{
- reqq.insert({smpi_process_index(), mpi_request});
+ reqq.insert({smpi_process()->index(), mpi_request});
}
//allocate a single buffer for all sends, growing it if needed
void* smpi_get_tmp_sendbuffer(int size)
{
- if (!smpi_process_get_replaying())
+ if (!smpi_process()->replaying())
return xbt_malloc(size);
if (sendbuffer_size<size){
sendbuffer=static_cast<char*>(xbt_realloc(sendbuffer,size));
//allocate a single buffer for all recv
void* smpi_get_tmp_recvbuffer(int size){
- if (!smpi_process_get_replaying())
+ if (!smpi_process()->replaying())
return xbt_malloc(size);
if (recvbuffer_size<size){
recvbuffer=static_cast<char*>(xbt_realloc(recvbuffer,size));
}
void smpi_free_tmp_buffer(void* buf){
- if (!smpi_process_get_replaying())
+ if (!smpi_process()->replaying())
xbt_free(buf);
}
break;
default:
MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE;
+ break;
}
return MPI_CURRENT_TYPE;
}
"Please contact the Simgrid team if support is needed", __FUNCTION__, i, mandatory, optional);\
}
+namespace simgrid {
+namespace smpi {
+
static void action_init(const char *const *action)
{
XBT_DEBUG("Initialize the counters");
else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype
/* start a simulated timer */
- smpi_process_simulated_start();
+ smpi_process()->simulated_start();
/*initialize the number of active processes */
active_processes = smpi_process_count();
static void action_comm_size(const char *const *action)
{
communicator_size = parse_double(action[2]);
- log_timed_action (action, smpi_process_simulated_elapsed());
+ log_timed_action (action, smpi_process()->simulated_elapsed());
}
static void action_comm_split(const char *const *action)
{
- log_timed_action (action, smpi_process_simulated_elapsed());
+ log_timed_action (action, smpi_process()->simulated_elapsed());
}
static void action_comm_dup(const char *const *action)
{
- log_timed_action (action, smpi_process_simulated_elapsed());
+ log_timed_action (action, smpi_process()->simulated_elapsed());
}
static void action_compute(const char *const *action)
{
CHECK_ACTION_PARAMS(action, 1, 0)
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
double flops= parse_double(action[2]);
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type=TRACING_COMPUTING;
extra->comp_size=flops;
CHECK_ACTION_PARAMS(action, 2, 1)
int to = atoi(action[2]);
double size=parse_double(action[3]);
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
if(action[4])
MPI_CURRENT_TYPE=decode_datatype(action[4]);
else
MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
int dst_traced = MPI_COMM_WORLD->group()->rank(to);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
CHECK_ACTION_PARAMS(action, 2, 1)
int to = atoi(action[2]);
double size=parse_double(action[3]);
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
if(action[4])
MPI_CURRENT_TYPE=decode_datatype(action[4]);
else
MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
int dst_traced = MPI_COMM_WORLD->group()->rank(to);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_ISEND;
CHECK_ACTION_PARAMS(action, 2, 1)
int from = atoi(action[2]);
double size=parse_double(action[3]);
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
MPI_Status status;
if(action[4])
else
MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
int src_traced = MPI_COMM_WORLD->group()->rank(from);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
CHECK_ACTION_PARAMS(action, 2, 1)
int from = atoi(action[2]);
double size=parse_double(action[3]);
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
if(action[4])
MPI_CURRENT_TYPE=decode_datatype(action[4]);
else
MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
int src_traced = MPI_COMM_WORLD->group()->rank(from);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_IRECV;
static void action_test(const char *const *action){
CHECK_ACTION_PARAMS(action, 0, 0)
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
MPI_Status status;
MPI_Request request = get_reqq_self()->back();
//Different times in traced application and replayed version may lead to this
//In this case, ignore the extra calls.
if(request!=nullptr){
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type=TRACING_TEST;
TRACE_smpi_testing_in(rank, extra);
static void action_wait(const char *const *action){
CHECK_ACTION_PARAMS(action, 0, 0)
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
MPI_Status status;
xbt_assert(get_reqq_self()->size(), "action wait not preceded by any irecv or isend: %s",
static void action_waitall(const char *const *action){
CHECK_ACTION_PARAMS(action, 0, 0)
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
unsigned int count_requests=get_reqq_self()->size();
if (count_requests>0) {
MPI_Status status[count_requests];
- int rank_traced = smpi_process_index();
+ int rank_traced = smpi_process()->index();
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_WAITALL;
extra->send_size=count_requests;
}
static void action_barrier(const char *const *action){
- double clock = smpi_process_simulated_elapsed();
- int rank = smpi_process_index();
+ double clock = smpi_process()->simulated_elapsed();
+ 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, -1, __FUNCTION__, extra);
- mpi_coll_barrier_fun(MPI_COMM_WORLD);
+ Colls::barrier(MPI_COMM_WORLD);
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
log_timed_action (action, clock);
{
CHECK_ACTION_PARAMS(action, 1, 2)
double size = parse_double(action[2]);
- double clock = smpi_process_simulated_elapsed();
+ 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;
MPI_CURRENT_TYPE=decode_datatype(action[4]);
}
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
int root_traced = MPI_COMM_WORLD->group()->index(root);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
- mpi_coll_bcast_fun(sendbuf, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD);
+ Colls::bcast(sendbuf, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD);
TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
log_timed_action (action, clock);
CHECK_ACTION_PARAMS(action, 2, 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;
MPI_CURRENT_TYPE=decode_datatype(action[5]);
}
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
int root_traced = MPI_COMM_WORLD->group()->rank(root);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_REDUCE;
void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
- mpi_coll_reduce_fun(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, root, MPI_COMM_WORLD);
+ 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, root_traced, __FUNCTION__);
else
MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
- double clock = smpi_process_simulated_elapsed();
- int rank = smpi_process_index();
+ double clock = smpi_process()->simulated_elapsed();
+ int rank = smpi_process()->index();
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_ALLREDUCE;
extra->send_size = comm_size;
void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
- mpi_coll_allreduce_fun(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD);
+ 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, -1, __FUNCTION__);
static void action_allToAll(const char *const *action) {
CHECK_ACTION_PARAMS(action, 2, 2) //two mandatory (send and recv volumes) and two optional (corresponding datatypes)
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
int comm_size = MPI_COMM_WORLD->size();
int send_size = parse_double(action[2]);
int recv_size = parse_double(action[3]);
void *send = smpi_get_tmp_sendbuffer(send_size*comm_size* MPI_CURRENT_TYPE->size());
void *recv = smpi_get_tmp_recvbuffer(recv_size*comm_size* MPI_CURRENT_TYPE2->size());
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_ALLTOALL;
extra->send_size = send_size;
TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
- mpi_coll_alltoall_fun(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
+ Colls::alltoall(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
log_timed_action (action, clock);
5) 0 is the recv datatype id, see decode_datatype()
*/
CHECK_ACTION_PARAMS(action, 2, 3)
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
int comm_size = MPI_COMM_WORLD->size();
int send_size = parse_double(action[2]);
int recv_size = parse_double(action[3]);
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
- TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra);
+ TRACE_smpi_collective_in(smpi_process()->index(), root, __FUNCTION__, extra);
- mpi_coll_gather_fun(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD);
+ 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(), -1, __FUNCTION__);
+ TRACE_smpi_collective_out(smpi_process()->index(), -1, __FUNCTION__);
log_timed_action (action, clock);
}
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();
+ double clock = smpi_process()->simulated_elapsed();
int comm_size = MPI_COMM_WORLD->size();
CHECK_ACTION_PARAMS(action, comm_size+1, 2)
int send_size = parse_double(action[2]);
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
- TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra);
+ TRACE_smpi_collective_in(smpi_process()->index(), root, __FUNCTION__, extra);
- smpi_mpi_gatherv(send, send_size, MPI_CURRENT_TYPE, recv, recvcounts, disps, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD);
+ 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(), -1, __FUNCTION__);
+ TRACE_smpi_collective_out(smpi_process()->index(), -1, __FUNCTION__);
log_timed_action (action, clock);
}
2) The value 11346849 is the amount of instructions
3) The last value corresponds to the datatype, see decode_datatype().
*/
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
int comm_size = MPI_COMM_WORLD->size();
CHECK_ACTION_PARAMS(action, comm_size+1, 1)
int comp_size = parse_double(action[2+comm_size]);
int recvcounts[comm_size];
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
int size = 0;
if(action[3+comm_size])
MPI_CURRENT_TYPE=decode_datatype(action[3+comm_size]);
void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
void *recvbuf = smpi_get_tmp_recvbuffer(size* MPI_CURRENT_TYPE->size());
- mpi_coll_reduce_scatter_fun(sendbuf, recvbuf, recvcounts, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD);
+ 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, -1, __FUNCTION__);
2) 275427 is the recvcount
3) No more values mean that the datatype for sent and receive buffer is the default one, see decode_datatype().
*/
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
CHECK_ACTION_PARAMS(action, 2, 2)
int sendcount=atoi(action[2]);
void *sendbuf = smpi_get_tmp_sendbuffer(sendcount* MPI_CURRENT_TYPE->size());
void *recvbuf = smpi_get_tmp_recvbuffer(recvcount* MPI_CURRENT_TYPE2->size());
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_ALLGATHER;
extra->send_size = sendcount;
TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
- mpi_coll_allgather_fun(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcount, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
+ Colls::allgather(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcount, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
log_timed_action (action, clock);
2) The next four elements declare the recvcounts array
3) No more values mean that the datatype for sent and receive buffer is the default one, see decode_datatype().
*/
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
int comm_size = MPI_COMM_WORLD->size();
CHECK_ACTION_PARAMS(action, comm_size+1, 2)
}
void *recvbuf = smpi_get_tmp_recvbuffer(recv_sum* MPI_CURRENT_TYPE2->size());
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_ALLGATHERV;
extra->send_size = sendcount;
TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
- mpi_coll_allgatherv_fun(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2,
+ Colls::allgatherv(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2,
MPI_COMM_WORLD);
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
3) 100*sizeof(int) is the size of the receiver buffer
4) 1 70 10 5 is the recvcounts array
*/
- double clock = smpi_process_simulated_elapsed();
+ double clock = smpi_process()->simulated_elapsed();
int comm_size = MPI_COMM_WORLD->size();
CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2)
recvdisps[i] = 0;
}
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_ALLTOALLV;
extra->recvcounts= xbt_new(int, comm_size);
TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
- mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE,recvbuf, recvcounts, recvdisps,
+ Colls::alltoallv(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE,recvbuf, recvcounts, recvdisps,
MPI_CURRENT_TYPE, MPI_COMM_WORLD);
TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
log_timed_action (action, clock);
}
+}} // namespace simgrid::smpi
+
void smpi_replay_run(int *argc, char***argv){
/* First initializes everything */
- smpi_process_init(argc, argv);
- smpi_process_mark_as_initialized();
- smpi_process_set_replaying(true);
+ simgrid::smpi::Process::init(argc, argv);
+ smpi_process()->mark_as_initialized();
+ smpi_process()->set_replaying(true);
- int rank = smpi_process_index();
+ int rank = smpi_process()->index();
TRACE_smpi_init(rank);
TRACE_smpi_computing_init(rank);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
TRACE_smpi_collective_in(rank, -1, operation, extra);
TRACE_smpi_collective_out(rank, -1, operation);
xbt_free(operation);
-
- if (_xbt_replay_action_init()==0) {
- xbt_replay_action_register("init", action_init);
- xbt_replay_action_register("finalize", action_finalize);
- xbt_replay_action_register("comm_size", action_comm_size);
- xbt_replay_action_register("comm_split", action_comm_split);
- xbt_replay_action_register("comm_dup", action_comm_dup);
- xbt_replay_action_register("send", action_send);
- xbt_replay_action_register("Isend", action_Isend);
- xbt_replay_action_register("recv", action_recv);
- xbt_replay_action_register("Irecv", action_Irecv);
- xbt_replay_action_register("test", action_test);
- xbt_replay_action_register("wait", action_wait);
- xbt_replay_action_register("waitAll", action_waitall);
- xbt_replay_action_register("barrier", action_barrier);
- xbt_replay_action_register("bcast", action_bcast);
- xbt_replay_action_register("reduce", action_reduce);
- xbt_replay_action_register("allReduce", action_allReduce);
- xbt_replay_action_register("allToAll", action_allToAll);
- xbt_replay_action_register("allToAllV", action_allToAllv);
- xbt_replay_action_register("gather", action_gather);
- xbt_replay_action_register("gatherV", action_gatherv);
- xbt_replay_action_register("allGather", action_allgather);
- xbt_replay_action_register("allGatherV", action_allgatherv);
- xbt_replay_action_register("reduceScatter", action_reducescatter);
- xbt_replay_action_register("compute", action_compute);
- }
+ 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);
+ xbt_replay_action_register("comm_split", simgrid::smpi::action_comm_split);
+ xbt_replay_action_register("comm_dup", simgrid::smpi::action_comm_dup);
+ xbt_replay_action_register("send", simgrid::smpi::action_send);
+ xbt_replay_action_register("Isend", simgrid::smpi::action_Isend);
+ xbt_replay_action_register("recv", simgrid::smpi::action_recv);
+ xbt_replay_action_register("Irecv", simgrid::smpi::action_Irecv);
+ xbt_replay_action_register("test", simgrid::smpi::action_test);
+ xbt_replay_action_register("wait", simgrid::smpi::action_wait);
+ xbt_replay_action_register("waitAll", simgrid::smpi::action_waitall);
+ xbt_replay_action_register("barrier", simgrid::smpi::action_barrier);
+ xbt_replay_action_register("bcast", simgrid::smpi::action_bcast);
+ xbt_replay_action_register("reduce", simgrid::smpi::action_reduce);
+ xbt_replay_action_register("allReduce", simgrid::smpi::action_allReduce);
+ xbt_replay_action_register("allToAll", simgrid::smpi::action_allToAll);
+ xbt_replay_action_register("allToAllV", simgrid::smpi::action_allToAllv);
+ xbt_replay_action_register("gather", simgrid::smpi::action_gather);
+ xbt_replay_action_register("gatherV", simgrid::smpi::action_gatherv);
+ xbt_replay_action_register("allGather", simgrid::smpi::action_allgather);
+ xbt_replay_action_register("allGatherV", simgrid::smpi::action_allgatherv);
+ xbt_replay_action_register("reduceScatter", simgrid::smpi::action_reducescatter);
+ xbt_replay_action_register("compute", simgrid::smpi::action_compute);
//if we have a delayed start, sleep here.
if(*argc>2){
}
/* Actually run the replay */
- xbt_replay_action_runner(*argc, *argv);
+ simgrid::xbt::replay_runner(*argc, *argv);
/* and now, finalize everything */
/* One active process will stop. Decrease the counter*/
requests[i] = req;
i++;
}
- Request::waitall(count_requests, requests, status);
+ simgrid::smpi::Request::waitall(count_requests, requests, status);
}
delete get_reqq_self();
active_processes--;
if(active_processes==0){
/* Last process alive speaking: end the simulated timer */
- XBT_INFO("Simulation time %f", smpi_process_simulated_elapsed());
- _xbt_replay_action_exit();
+ XBT_INFO("Simulation time %f", smpi_process()->simulated_elapsed());
xbt_free(sendbuffer);
xbt_free(recvbuffer);
}
operation =bprintf("%s_finalize",__FUNCTION__);
TRACE_smpi_collective_in(rank, -1, operation, extra_fin);
- smpi_process_finalize();
+ smpi_process()->finalize();
TRACE_smpi_collective_out(rank, -1, operation);
- TRACE_smpi_finalize(smpi_process_index());
- smpi_process_destroy();
+ TRACE_smpi_finalize(smpi_process()->index());
xbt_free(operation);
}
