smpi_global.cpp File Reference

#include "SmpiHost.hpp"
#include "mc/mc.h"
#include "private.hpp"
#include "simgrid/s4u/Host.hpp"
#include "simgrid/s4u/Mailbox.hpp"
#include "smpi_coll.hpp"
#include "smpi_comm.hpp"
#include "smpi_group.hpp"
#include "smpi_info.hpp"
#include "smpi_process.hpp"
#include "src/msg/msg_private.hpp"
#include "src/simix/smx_private.hpp"
#include "src/surf/surf_interface.hpp"
#include "xbt/config.hpp"
#include <cfloat>
#include <dlfcn.h>
#include <fcntl.h>
#include <fstream>
#include <sys/stat.h>
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string.hpp>

Macros
#define	RTLD_DEEPBIND   0

Typedefs
typedef std::function< int(int argc, char *argv[])>	smpi_entry_point_type
typedef int(*	smpi_c_entry_point_type) (int argc, char **argv)
typedef void(*	smpi_fortran_entry_point_type) ()

Functions
	XBT_LOG_NEW_DEFAULT_SUBCATEGORY (smpi_kernel, smpi, "Logging specific to SMPI (kernel)")
int	smpi_process_count ()
simgrid::smpi::Process *	smpi_process ()
simgrid::smpi::Process *	smpi_process_remote (int index)
MPI_Comm	smpi_process_comm_self ()
void	smpi_process_init (int *argc, char ***argv)
int	smpi_process_index ()
void *	smpi_process_get_user_data ()
void	smpi_process_set_user_data (void *data)
int	smpi_global_size ()
void	smpi_comm_set_copy_data_callback (void(*callback)(smx_activity_t, void *, size_t))
	Need a public setter for SMPI copy_callback function, so users can define their own while still using default SIMIX_copy_callback for MSG copies. More...
static void	print (std::vector< std::pair< size_t, size_t >> vec)
static void	memcpy_private (void *dest, const void *src, std::vector< std::pair< size_t, size_t >> &private_blocks)
static void	check_blocks (std::vector< std::pair< size_t, size_t >> &private_blocks, size_t buff_size)
void	smpi_comm_copy_buffer_callback (smx_activity_t synchro, void *buff, size_t buff_size)
void	smpi_comm_null_copy_buffer_callback (smx_activity_t comm, void *buff, size_t buff_size)
static void	smpi_check_options ()
int	smpi_enabled ()
void	smpi_global_init ()
void	smpi_global_destroy ()
static void	smpi_init_logs ()
static void	smpi_init_options ()
static int	smpi_run_entry_point (smpi_entry_point_type entry_point, std::vector< std::string > args)
static smpi_entry_point_type	smpi_resolve_function (void *handle)
int	smpi_main (const char *executable, int argc, char *argv[])
void	SMPI_init ()
void	SMPI_finalize ()
void	smpi_mpi_init ()
double	smpi_mpi_wtime ()

Variables
std::unordered_map< std::string, double >	location2speedup
static simgrid::smpi::Process **	process_data = nullptr
int	process_count = 0
int	smpi_universe_size = 0
int *	index_to_process_data = nullptr
double	smpi_total_benched_time
xbt_os_timer_t	global_timer
MPI_Comm	MPI_COMM_WORLD = MPI_COMM_UNINITIALIZED
	Setting MPI_COMM_WORLD to MPI_COMM_UNINITIALIZED (it's a variable) is important because the implementation of MPI_Comm checks "this == MPI_COMM_UNINITIALIZED"? If yes, it uses smpi_process()->comm_world() instead of "this". More...
MPI_Errhandler *	MPI_ERRORS_RETURN = nullptr
MPI_Errhandler *	MPI_ERRORS_ARE_FATAL = nullptr
MPI_Errhandler *	MPI_ERRHANDLER_NULL = nullptr
static const char *	smpi_default_instance_name = "smpirun"
static simgrid::config::Flag< double >	smpi_wtime_sleep ("smpi/wtime", "Minimum time to inject inside a call to MPI_Wtime", 0.0)
static simgrid::config::Flag< double >	smpi_init_sleep ("smpi/init", "Time to inject inside a call to MPI_Init", 0.0)
void(*	smpi_comm_copy_data_callback )(smx_activity_t, void *, size_t) = &smpi_comm_copy_buffer_callback

Macro Definition Documentation

RTLD_DEEPBIND

#define RTLD_DEEPBIND   0

Typedef Documentation

smpi_entry_point_type

typedef std::function<int(int argc, char *argv[])> smpi_entry_point_type

smpi_c_entry_point_type

typedef int(* smpi_c_entry_point_type) (int argc, char **argv)

smpi_fortran_entry_point_type

typedef void(* smpi_fortran_entry_point_type) ()

Function Documentation

XBT_LOG_NEW_DEFAULT_SUBCATEGORY()

XBT_LOG_NEW_DEFAULT_SUBCATEGORY	(	smpi_kernel	,
		smpi	,
		"Logging specific to SMPI (kernel)"
	)

smpi_process_count()

int smpi_process_count

(

)

smpi_process()

simgrid::smpi::Process* smpi_process

(

)

smpi_process_remote()

simgrid::smpi::Process* smpi_process_remote

(

int

index

)

smpi_process_comm_self()

MPI_Comm smpi_process_comm_self

(

)

smpi_process_init()

void smpi_process_init	(	int *	argc,
		char ***	argv
	)

smpi_process_index()

int smpi_process_index

(

)

smpi_process_get_user_data()

void* smpi_process_get_user_data

(

)

smpi_process_set_user_data()

void smpi_process_set_user_data

(

void *

data

)

smpi_global_size()

int smpi_global_size

(

)

smpi_comm_set_copy_data_callback()

void smpi_comm_set_copy_data_callback

(

void(*)(smx_activity_t, void *, size_t)

callback

)

Need a public setter for SMPI copy_callback function, so users can define their own while still using default SIMIX_copy_callback for MSG copies.

print()

static void print ( std::vector< std::pair< size_t, size_t >>  vec )

static

memcpy_private()

static void memcpy_private ( void *  dest, const void *  src, std::vector< std::pair< size_t, size_t >> &  private_blocks  )

static

check_blocks()

static void check_blocks ( std::vector< std::pair< size_t, size_t >> &  private_blocks, size_t  buff_size  )

static

smpi_comm_copy_buffer_callback()

void smpi_comm_copy_buffer_callback	(	smx_activity_t	synchro,
		void *	buff,
		size_t	buff_size
	)

smpi_comm_null_copy_buffer_callback()

void smpi_comm_null_copy_buffer_callback	(	smx_activity_t	comm,
		void *	buff,
		size_t	buff_size
	)

smpi_check_options()

static void smpi_check_options ( )

static

smpi_enabled()

int smpi_enabled

(

)

smpi_global_init()

void smpi_global_init

(

)

smpi_global_destroy()

void smpi_global_destroy

(

)

smpi_init_logs()

static void smpi_init_logs ( )

static

smpi_init_options()

static void smpi_init_options ( )

static

smpi_run_entry_point()

static int smpi_run_entry_point ( smpi_entry_point_type  entry_point, std::vector< std::string >  args  )

static

smpi_resolve_function()

static smpi_entry_point_type smpi_resolve_function ( void *  handle )

static

smpi_main()

int smpi_main	(	const char *	executable,
		int	argc,
		char *	argv[]
	)

SMPI_init()

void SMPI_init

(

)

SMPI_finalize()

void SMPI_finalize

(

)

smpi_mpi_init()

void smpi_mpi_init

(

)

smpi_mpi_wtime()

double smpi_mpi_wtime

(

)

Variable Documentation

location2speedup

std::unordered_map<std::string, double> location2speedup

process_data

simgrid::smpi::Process** process_data = nullptr

static

process_count

int process_count = 0

smpi_universe_size

int smpi_universe_size = 0

index_to_process_data

int* index_to_process_data = nullptr

smpi_total_benched_time

double smpi_total_benched_time

global_timer

xbt_os_timer_t global_timer

MPI_COMM_WORLD

MPI_Comm MPI_COMM_WORLD = MPI_COMM_UNINITIALIZED

Setting MPI_COMM_WORLD to MPI_COMM_UNINITIALIZED (it's a variable) is important because the implementation of MPI_Comm checks "this == MPI_COMM_UNINITIALIZED"? If yes, it uses smpi_process()->comm_world() instead of "this".

This is basically how we only have one global variable but all processes have different communicators (basically, the one their SMPI instance uses).

See smpi_comm.cpp and the functions therein for details.

MPI_ERRORS_RETURN

MPI_Errhandler* MPI_ERRORS_RETURN = nullptr

MPI_ERRORS_ARE_FATAL

MPI_Errhandler* MPI_ERRORS_ARE_FATAL = nullptr

MPI_ERRHANDLER_NULL

MPI_Errhandler* MPI_ERRHANDLER_NULL = nullptr

smpi_default_instance_name

const char* smpi_default_instance_name = "smpirun"

static

smpi_wtime_sleep

simgrid::config::Flag<double> smpi_wtime_sleep("smpi/wtime", "Minimum time to inject inside a call to MPI_Wtime", 0.0)

static

smpi_init_sleep

simgrid::config::Flag<double> smpi_init_sleep("smpi/init", "Time to inject inside a call to MPI_Init", 0.0)

static

smpi_comm_copy_data_callback

void(* smpi_comm_copy_data_callback) (smx_activity_t, void *, size_t) = &smpi_comm_copy_buffer_callback