char state;
int sampling; /* inside an SMPI_SAMPLE_ block? */
char* instance_id;
+ int replaying; /* is the process replaying a trace */
xbt_bar_t finalization_barrier;
} s_smpi_process_data_t;
static smpi_process_data_t *process_data = NULL;
int process_count = 0;
int* index_to_process_data = NULL;
-
-
+extern double smpi_total_benched_time;
+xbt_os_timer_t global_timer;
MPI_Comm MPI_COMM_WORLD = MPI_COMM_UNINITIALIZED;
int MPI_UNIVERSE_SIZE;
proc->context->cleanup_func=SIMIX_process_cleanup;
char* instance_id = (*argv)[1];
int rank = atoi((*argv)[2]);
- index = SIMIX_process_get_PID(proc) -1;
+ index = smpi_process_index_of_smx_process(proc);
if(!index_to_process_data){
index_to_process_data=(int*)xbt_malloc(SIMIX_process_count()*sizeof(int));
if(temp_bar != NULL) data->finalization_barrier = temp_bar;
data->index = index;
data->instance_id = instance_id;
+ data->replaying = 0;
xbt_free(simcall_process_get_data(proc));
simcall_process_set_data(proc, data);
if (*argc > 3) {
free((*argv)[1]);
- free((*argv)[2]);
- memmove(&(*argv)[1], &(*argv)[3], sizeof(char *) * (*argc - 3));
+ memmove(&(*argv)[0], &(*argv)[2], sizeof(char *) * (*argc - 2));
(*argv)[(*argc) - 1] = NULL;
(*argv)[(*argc) - 2] = NULL;
}
XBT_DEBUG("<%d> New process in the game: %p", index, proc);
if(smpi_privatize_global_variables){
- switch_data_segment(index);
+ smpi_switch_data_segment(index);
}
}
{
int index = smpi_process_index();
if(smpi_privatize_global_variables){
- switch_data_segment(index);
+ smpi_switch_data_segment(index);
}
process_data[index_to_process_data[index]]->state = SMPI_FINALIZED;
XBT_DEBUG("<%d> Process left the game", index);
void smpi_process_mark_as_initialized(void)
{
int index = smpi_process_index();
- if ((index != MPI_UNDEFINED) && (!process_data[index_to_process_data[index]]->state != SMPI_FINALIZED))
+ if ((index != MPI_UNDEFINED) && (process_data[index_to_process_data[index]]->state != SMPI_FINALIZED))
process_data[index_to_process_data[index]]->state = SMPI_INITIALIZED;
}
+void smpi_process_set_replaying(int value){
+ int index = smpi_process_index();
+ if ((index != MPI_UNDEFINED) && (process_data[index_to_process_data[index]]->state != SMPI_FINALIZED))
+ process_data[index_to_process_data[index]]->replaying = value;
+}
+
+int smpi_process_get_replaying(){
+ int index = smpi_process_index();
+ if (index != MPI_UNDEFINED)
+ return process_data[index_to_process_data[index]]->replaying;
+ else return _xbt_replay_is_active();
+}
+
int smpi_global_size(void)
{
return data ? data->index : MPI_UNDEFINED;
}
-int smpi_process_index_of_smx_process(smx_process_t process) {
- smpi_process_data_t data = SIMIX_process_get_data(process);
- return data ? data->index : MPI_UNDEFINED;
-}
-
MPI_Comm smpi_process_comm_world(void)
{
smpi_process_data_t data = smpi_process_data();
void print_request(const char *message, MPI_Request request)
{
- XBT_DEBUG
+ XBT_VERB
("%s request %p [buf = %p, size = %zu, src = %d, dst = %d, tag = %d, flags = %x]",
message, request, request->buf, request->size, request->src,
request->dst, request->tag, request->flags);
}
-void smpi_comm_copy_buffer_callback(smx_action_t comm,
+void smpi_comm_copy_buffer_callback(smx_synchro_t comm,
void *buff, size_t buff_size)
{
XBT_DEBUG("Copy the data over");
- if(_xbt_replay_is_active()) return;
void* tmpbuff=buff;
if((smpi_privatize_global_variables)
&& ((char*)buff < start_data_exe + size_data_exe )
){
XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !");
- switch_data_segment(((smpi_process_data_t)SIMIX_process_get_data(comm->comm.src_proc))->index);
+ smpi_switch_data_segment(((smpi_process_data_t)SIMIX_process_get_data(comm->comm.src_proc))->index);
tmpbuff = (void*)xbt_malloc(buff_size);
memcpy(tmpbuff, buff, buff_size);
}
&& ((char*)comm->comm.dst_buff < start_data_exe + size_data_exe )
){
XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment");
- switch_data_segment(((smpi_process_data_t)SIMIX_process_get_data(comm->comm.dst_proc))->index);
+ smpi_switch_data_segment(((smpi_process_data_t)SIMIX_process_get_data(comm->comm.dst_proc))->index);
}
}
+
+void smpi_comm_null_copy_buffer_callback(smx_synchro_t comm,
+ void *buff, size_t buff_size)
+{
+ return;
+}
+
static void smpi_check_options(){
//check correctness of MPI parameters
char name[MAILBOX_NAME_MAXLEN];
int smpirun=0;
-
+ global_timer = xbt_os_timer_new();
+ xbt_os_walltimer_start(global_timer);
if (process_count == 0){
process_count = SIMIX_process_count();
smpirun=1;
SIMIX_global_init(&argc, argv);
+ smpi_init_options();
+
// parse the platform file: get the host list
SIMIX_create_environment(argv[1]);
SIMIX_comm_set_copy_data_callback(&smpi_comm_copy_buffer_callback);
SIMIX_function_register_default(realmain);
SIMIX_launch_application(argv[2]);
- smpi_init_options();
-
smpi_global_init();
smpi_check_options();
MC_do_the_modelcheck_for_real();
else
SIMIX_run();
+ xbt_os_walltimer_stop(global_timer);
+ if (sg_cfg_get_boolean("smpi/display_timing")){
+ double global_time = xbt_os_timer_elapsed(global_timer);
+ XBT_INFO("Simulated time: %g seconds. \n "
+ "The simulation took %g seconds (after parsing and platform setup)\n"
+ "%g seconds were actual computation of the application"
+ , SIMIX_get_clock(), global_time , smpi_total_benched_time);
+
+ if (smpi_total_benched_time/global_time>=0.75)
+ XBT_INFO("More than 75%% of the time was spent inside the application code.\n"
+ "You may want to use sampling functions or trace replay to reduce this.");
- if (sg_cfg_get_boolean("smpi/display_timing"))
- XBT_INFO("Simulation time: %g seconds.", SIMIX_get_clock());
+ }
smpi_global_destroy();
