/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
-#include "private.h"
+#include "src/smpi/private.h"
+#include "src/smpi/smpi_coll.hpp"
+#include "src/smpi/smpi_comm.hpp"
+#include "src/smpi/smpi_datatype.hpp"
+#include "src/smpi/smpi_group.hpp"
+#include "src/smpi/smpi_process.hpp"
+#include "src/smpi/smpi_request.hpp"
#include "xbt/replay.hpp"
+
#include <unordered_map>
#include <vector>
#define KEY_SIZE (sizeof(int) * 2 + 1)
-using namespace simgrid::smpi;
-
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_replay,smpi,"Trace Replay with SMPI");
int communicator_size = 0;
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 (not 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 (not 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 (not 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");
CHECK_ACTION_PARAMS(action, 0, 1)
- if(action[2])
- MPI_DEFAULT_TYPE=MPI_DOUBLE; // default MPE dataype
+ if(action[2])
+ MPI_DEFAULT_TYPE=MPI_DOUBLE; // default MPE dataype
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);
extra->dst = dst_traced;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
- if (!TRACE_smpi_view_internals())
+ if (not TRACE_smpi_view_internals())
TRACE_smpi_send(rank, rank, dst_traced, 0, size*MPI_CURRENT_TYPE->size());
Request::send(nullptr, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD);
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])
+ if(action[4])
MPI_CURRENT_TYPE=decode_datatype(action[4]);
- else
+ 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;
extra->dst = dst_traced;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
- if (!TRACE_smpi_view_internals())
+ 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);
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])
+ if(action[4])
MPI_CURRENT_TYPE=decode_datatype(action[4]);
- else
+ 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);
Request::recv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
- if (!TRACE_smpi_view_internals()) {
+ if (not TRACE_smpi_view_internals()) {
TRACE_smpi_recv(rank, src_traced, rank, 0);
}
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])
+ if(action[4])
MPI_CURRENT_TYPE=decode_datatype(action[4]);
- else
+ 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();
get_reqq_self()->pop_back();
- //if request is null here, this may mean that a previous test has succeeded
- //Different times in traced application and replayed version may lead to this
+ //if request is null here, this may mean that a previous test has succeeded
+ //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);
{
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= MPI_DEFAULT_TYPE;
if(action[3]) {
root= atoi(action[3]);
if(action[4])
- MPI_CURRENT_TYPE=decode_datatype(action[4]);
+ 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);
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;
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;
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;
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);
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);
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]);
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]);
- int recvcount=atoi(action[3]);
+ int sendcount=atoi(action[2]);
+ int recvcount=atoi(action[3]);
MPI_Datatype MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE;
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;
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;
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);
log_timed_action (action, clock);
}
-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);
+}} // namespace simgrid::smpi
- int rank = smpi_process_index();
+/** @brief Only initialize the replay, don't do it for real */
+void smpi_replay_init(int* argc, char*** argv)
+{
+ simgrid::smpi::Process::init(argc, argv);
+ smpi_process()->mark_as_initialized();
+ smpi_process()->set_replaying(true);
+
+ 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);
extra->type = TRACING_INIT;
- char *operation =bprintf("%s_init",__FUNCTION__);
- TRACE_smpi_collective_in(rank, -1, operation, extra);
- TRACE_smpi_collective_out(rank, -1, operation);
- xbt_free(operation);
- simgrid::xbt::replay_init();
- 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);
+ TRACE_smpi_collective_in(rank, -1, "smpi_replay_run_init", extra);
+ TRACE_smpi_collective_out(rank, -1, "smpi_replay_run_init");
+ 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){
- char *endptr;
- double value = strtod((*argv)[2], &endptr);
- if (*endptr != '\0')
- THROWF(unknown_error, 0, "%s is not a double", (*argv)[2]);
+ double value = xbt_str_parse_double((*argv)[2], "%s is not a double");
XBT_VERB("Delayed start for instance - Sleeping for %f flops ",value );
smpi_execute_flops(value);
} else {
XBT_DEBUG("Force context switch by smpi_execute_flops - Sleeping for 0.0 flops ");
smpi_execute_flops(0.0);
}
+}
- /* Actually run the replay */
+/** @brief actually run the replay after initialization */
+void smpi_replay_main(int* argc, char*** argv)
+{
simgrid::xbt::replay_runner(*argc, *argv);
/* and now, finalize everything */
/* One active process will stop. Decrease the counter*/
XBT_DEBUG("There are %zu elements in reqq[*]", get_reqq_self()->size());
- if (!get_reqq_self()->empty()){
+ if (not get_reqq_self()->empty()) {
unsigned int count_requests=get_reqq_self()->size();
MPI_Request requests[count_requests];
MPI_Status status[count_requests];
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());
- simgrid::xbt::replay_exit();
+ XBT_INFO("Simulation time %f", smpi_process()->simulated_elapsed());
xbt_free(sendbuffer);
xbt_free(recvbuffer);
}
instr_extra_data extra_fin = xbt_new0(s_instr_extra_data_t,1);
extra_fin->type = TRACING_FINALIZE;
- operation =bprintf("%s_finalize",__FUNCTION__);
- TRACE_smpi_collective_in(rank, -1, operation, extra_fin);
+ TRACE_smpi_collective_in(smpi_process()->index(), -1, "smpi_replay_run_finalize", extra_fin);
+
+ smpi_process()->finalize();
- smpi_process_finalize();
+ TRACE_smpi_collective_out(smpi_process()->index(), -1, "smpi_replay_run_finalize");
+ TRACE_smpi_finalize(smpi_process()->index());
+}
- TRACE_smpi_collective_out(rank, -1, operation);
- TRACE_smpi_finalize(smpi_process_index());
- smpi_process_destroy();
- xbt_free(operation);
+/** @brief chain a replay initialization and a replay start */
+void smpi_replay_run(int* argc, char*** argv)
+{
+ smpi_replay_init(argc, argv);
+ smpi_replay_main(argc, argv);
}
