smx_rdv_t mailbox_small;
xbt_os_timer_t timer;
MPI_Comm comm_self;
+ MPI_Comm comm_intra;
MPI_Comm* comm_world;
void *data; /* user data */
int index;
char state;
int sampling; /* inside an SMPI_SAMPLE_ block? */
char* instance_id;
+ xbt_bar_t finalization_barrier;
} s_smpi_process_data_t;
static smpi_process_data_t *process_data = NULL;
int rank = atoi((*argv)[2]);
index = SIMIX_process_get_PID(proc) -1;
-#ifdef SMPI_F2C
- smpi_current_rank = index;
-#endif
if(!index_to_process_data){
index_to_process_data=(int*)xbt_malloc(SIMIX_process_count()*sizeof(int));
}
- MPI_Comm* temp_comm_world = smpi_deployment_register_process(instance_id, rank, index);
+ MPI_Comm* temp_comm_world;
+ xbt_bar_t temp_bar;
+ smpi_deployment_register_process(instance_id, rank, index, &temp_comm_world ,&temp_bar);
data = smpi_process_remote_data(index);
data->comm_world = temp_comm_world;
+ if(temp_bar != NULL) data->finalization_barrier = temp_bar;
data->index = index;
data->instance_id = instance_id;
+ xbt_free(simcall_process_get_data(proc));
simcall_process_set_data(proc, data);
if (*argc > 3) {
free((*argv)[1]);
data->argv = argv;
// set the process attached to the mailbox
simcall_rdv_set_receiver(data->mailbox_small, proc);
+
XBT_DEBUG("<%d> New process in the game: %p", index, proc);
if(smpi_privatize_global_variables){
*/
void smpi_process_finalize(void)
{
-#if 0
- // wait for all pending asynchronous comms to finish
- while (SIMIX_process_has_pending_comms(SIMIX_process_self())) {
- simcall_process_sleep(0.01);
- }
-#else
- int i;
- int size = smpi_comm_size(MPI_COMM_WORLD);
- int rank = smpi_comm_rank(MPI_COMM_WORLD);
- /* All non-root send & receive zero-length message. */
- if (rank > 0) {
- smpi_mpi_ssend (NULL, 0, MPI_BYTE, 0,
- COLL_TAG_BARRIER,
- MPI_COMM_WORLD);
- smpi_mpi_recv (NULL, 0, MPI_BYTE, 0,
- COLL_TAG_BARRIER,
- MPI_COMM_WORLD, MPI_STATUS_IGNORE);
- }
- /* The root collects and broadcasts the messages. */
- else {
- MPI_Request* requests;
- requests = (MPI_Request*)malloc( size * sizeof(MPI_Request) );
- for (i = 1; i < size; ++i) {
- requests[i] = smpi_mpi_irecv(NULL, 0, MPI_BYTE, MPI_ANY_SOURCE,
- COLL_TAG_BARRIER, MPI_COMM_WORLD
- );
- }
- smpi_mpi_waitall( size-1, requests+1, MPI_STATUSES_IGNORE );
- for (i = 1; i < size; ++i) {
- requests[i] = smpi_mpi_issend(NULL, 0, MPI_BYTE, i,
- COLL_TAG_BARRIER,
- MPI_COMM_WORLD
- );
- }
- smpi_mpi_waitall( size-1, requests+1, MPI_STATUSES_IGNORE );
- free( requests );
- }
-#endif
+ // This leads to an explosion of the search graph
+ // which cannot be reduced:
+ if(MC_is_active())
+ return;
+
+ int index = smpi_process_index();
+ // wait for all pending asynchronous comms to finish
+ xbt_barrier_wait(process_data[index_to_process_data[index]]->finalization_barrier);
}
/**
}
-#ifdef SMPI_F2C
-int smpi_process_argc(void)
-{
- smpi_process_data_t data = smpi_process_data();
- return data->argc ? *(data->argc) - 1 : 0;
-}
-
-int smpi_process_getarg(integer * index, char *dst, ftnlen len)
-{
- smpi_process_data_t data = smpi_process_data();
- char *arg;
- ftnlen i;
-
- if (!data->argc || !data->argv || *index < 1 || *index >= *(data->argc)) {
- return -1;
- }
- arg = (*data->argv)[*index];
- for (i = 0; i < len && arg[i] != '\0'; i++) {
- dst[i] = arg[i];
- }
- for (; i < len; i++) {
- dst[i] = ' ';
- }
- return 0;
-}
-#endif
-
int smpi_global_size(void)
{
char *value = getenv("SMPI_GLOBAL_SIZE");
return data ? data->index : MPI_UNDEFINED;
}
+int smpi_process_index_of_smx_process(smx_process_t process) {
+ smpi_process_data_t data = (smpi_process_data_t) 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();
return data->comm_self;
}
+MPI_Comm smpi_process_get_comm_intra(void)
+{
+ smpi_process_data_t data = smpi_process_data();
+ return data->comm_intra;
+}
+
+void smpi_process_set_comm_intra(MPI_Comm comm)
+{
+ smpi_process_data_t data = smpi_process_data();
+ data->comm_intra = comm;
+}
+
void smpi_process_set_sampling(int s)
{
smpi_process_data_t data = smpi_process_data();
return data->sampling;
}
+
void print_request(const char *message, MPI_Request request)
{
XBT_DEBUG
XBT_INFO("You did not set the power of the host running the simulation. "
"The timings will certainly not be accurate. "
"Use the option \"--cfg=smpi/running_power:<flops>\" to set its value."
- "Check http://simgrid.org/simgrid/latest/doc/options.html#options_smpi_bench for more information. ");
+ "Check http://simgrid.org/simgrid/latest/doc/options.html#options_smpi_bench for more information.");
}
}
+int smpi_enabled(void) {
+ return process_data != NULL;
+}
+
void smpi_global_init(void)
{
int i;
if (MC_is_active())
MC_ignore_heap(process_data[i]->timer, xbt_os_timer_size());
process_data[i]->comm_self = MPI_COMM_NULL;
+ process_data[i]->comm_intra = MPI_COMM_NULL;
process_data[i]->comm_world = NULL;
process_data[i]->state = SMPI_UNINITIALIZED;
process_data[i]->sampling = 0;
+ process_data[i]->finalization_barrier = NULL;
}
//if the process was launched through smpirun script
//we generate a global mpi_comm_world
if(smpirun){
group = smpi_group_new(process_count);
MPI_COMM_WORLD = smpi_comm_new(group, NULL);
+ xbt_bar_t bar=xbt_barrier_init(process_count);
+
MPI_UNIVERSE_SIZE = smpi_comm_size(MPI_COMM_WORLD);
for (i = 0; i < process_count; i++) {
smpi_group_set_mapping(group, i, i);
+ process_data[i]->finalization_barrier = bar;
}
}
}
if (MPI_COMM_WORLD != MPI_COMM_UNINITIALIZED){
while (smpi_group_unuse(smpi_comm_group(MPI_COMM_WORLD)) > 0);
xbt_free(MPI_COMM_WORLD);
+ xbt_barrier_destroy(process_data[0]->finalization_barrier);
+ }else{
+ smpi_deployment_cleanup_instances();
}
MPI_COMM_WORLD = MPI_COMM_NULL;
for (i = 0; i < count; i++) {
smpi_group_unuse(smpi_comm_group(process_data[i]->comm_self));
smpi_comm_destroy(process_data[i]->comm_self);
}
+ if(process_data[i]->comm_intra!=MPI_COMM_NULL){
+ smpi_group_unuse(smpi_comm_group(process_data[i]->comm_intra));
+ smpi_comm_destroy(process_data[i]->comm_intra);
+ }
xbt_os_timer_free(process_data[i]->timer);
simcall_rdv_destroy(process_data[i]->mailbox);
simcall_rdv_destroy(process_data[i]->mailbox_small);
}
xbt_free(process_data);
process_data = NULL;
+
+ xbt_free(index_to_process_data);
if(smpi_privatize_global_variables)
smpi_destroy_global_memory_segments();
smpi_free_static();
}
-/* Fortran specific stuff */
-/* With smpicc, the following weak symbols are used */
-/* With smpiff, the following weak symbols are replaced by those in libf2c */
-int __attribute__ ((weak)) xargc;
-char ** __attribute__ ((weak)) xargv;
-
#ifndef WIN32
void __attribute__ ((weak)) user_main_()
{
return smpi_main(smpi_simulated_main_, argc, argv);
}
-int __attribute__ ((weak)) MAIN__()
-{
- return smpi_main(smpi_simulated_main_, xargc, xargv);
-};
#endif
static void smpi_init_logs(){
XBT_LOG_CONNECT(smpi_mpi_dt);
XBT_LOG_CONNECT(smpi_pmpi);
XBT_LOG_CONNECT(smpi_replay);
+ XBT_LOG_CONNECT(smpi_rma);
}
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();
