static void linkContainers (container_t src, container_t dst, xbt_dict_t filter)
{
//ignore loopback
if (strcmp (src->name, "__loopback__") == 0 || strcmp (dst->name, "__loopback__") == 0){
XBT_DEBUG (" linkContainers: ignoring loopback link");
return;
}
//find common father
container_t father = lowestCommonAncestor (src, dst);
if (!father){
xbt_die ("common father unknown, this is a tracing problem");
}
if (filter != NULL){
//check if we already register this pair (we only need one direction)
char aux1[INSTR_DEFAULT_STR_SIZE], aux2[INSTR_DEFAULT_STR_SIZE];
snprintf (aux1, INSTR_DEFAULT_STR_SIZE, "%s%s", src->name, dst->name);
snprintf (aux2, INSTR_DEFAULT_STR_SIZE, "%s%s", dst->name, src->name);
if (xbt_dict_get_or_null (filter, aux1)){
XBT_DEBUG (" linkContainers: already registered %s <-> %s (1)", src->name, dst->name);
return;
}
if (xbt_dict_get_or_null (filter, aux2)){
XBT_DEBUG (" linkContainers: already registered %s <-> %s (2)", dst->name, src->name);
return;
}
//ok, not found, register it
xbt_dict_set (filter, aux1, xbt_strdup ("1"), NULL);
xbt_dict_set (filter, aux2, xbt_strdup ("1"), NULL);
}
//declare type
char link_typename[INSTR_DEFAULT_STR_SIZE];
snprintf (link_typename, INSTR_DEFAULT_STR_SIZE, "%s-%s%s-%s%s",
father->type->name,
src->type->name, src->type->id,
dst->type->name, dst->type->id);
type_t link_type = PJ_type_get_or_null (link_typename, father->type);
if (link_type == NULL){
link_type = PJ_type_link_new (link_typename, father->type, src->type, dst->type);
}
//register EDGE types for triva configuration
xbt_dict_set (trivaEdgeTypes, link_type->name, xbt_strdup("1"), NULL);
//create the link
static long long counter = 0;
char key[INSTR_DEFAULT_STR_SIZE];
snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", counter++);
new_pajeStartLink(SIMIX_get_clock(), father, link_type, src, "topology", key);
new_pajeEndLink(SIMIX_get_clock(), father, link_type, dst, "topology", key);
XBT_DEBUG (" linkContainers %s <-> %s", src->name, dst->name);
}
void TRACE_smpi_computing_out(int rank)
{
if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_computing()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
new_pajePopState (SIMIX_get_clock(), container, type);
}
unsigned long long smpi_rastro_timestamp (void)
{
smpi_bench_end();
double now = SIMIX_get_clock();
unsigned long long sec = (unsigned long long)now;
unsigned long long pre = (now - sec) * smpi_rastro_resolution();
smpi_bench_begin();
return (unsigned long long)sec * smpi_rastro_resolution() + pre;
}
int smpi_gettimeofday(struct timeval *tv, struct timezone *tz)
{
double now = SIMIX_get_clock();
if (tv) {
tv->tv_sec = (time_t) now;
tv->tv_usec = (suseconds_t) (now * 1e6);
}
return 0;
}
void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation)
{
if (!TRACE_smpi_is_enabled()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
new_pajePopState (SIMIX_get_clock(), container, type);
}
/**
* \ingroup simix_process_management
* \brief Set the kill time of a process.
*/
void simcall_process_set_kill_time(smx_process_t process, double kill_time)
{
if (kill_time > SIMIX_get_clock()) {
if (simix_global->kill_process_function) {
XBT_DEBUG("Set kill time %f for process %s(%s)",kill_time, process->name,
sg_host_get_name(process->host));
process->kill_timer = SIMIX_timer_set(kill_time, kill_process_from_timer, process);
}
}
}
StateEvent::StateEvent(Container* container, Type* type, e_event_type event_type, EntityValue* value, TIData* extra)
: PajeEvent::PajeEvent(container, type, SIMIX_get_clock(), event_type), value(value), extra_(extra)
{
#if HAVE_SMPI
if (simgrid::config::get_value<bool>("smpi/trace-call-location")) {
smpi_trace_call_location_t* loc = smpi_trace_get_call_location();
filename = loc->filename;
linenumber = loc->linenumber;
}
#endif
}
void TRACE_smpi_collective_in(int rank, int root, const char *operation)
{
if (!TRACE_smpi_is_enabled()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
const char *color = instr_find_color (operation);
val_t value = PJ_value_get_or_new (operation, color, type);
new_pajePushState (SIMIX_get_clock(), container, type, value);
}
void TRACE_smpi_computing_in(int rank)
{
//do not forget to set the color first, otherwise this will explode
if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_computing()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
val_t value = PJ_value_get_or_new ("computing", NULL, type);
new_pajePushState (SIMIX_get_clock(), container, type, value);
}
/**
* \ingroup simix_process_management
* \brief Set the kill time of a process.
*/
void simcall_process_set_kill_time(smx_actor_t process, double kill_time)
{
if (kill_time <= SIMIX_get_clock() || simix_global->kill_process_function == nullptr)
return;
XBT_DEBUG("Set kill time %f for process %s(%s)",
kill_time, process->name.c_str(), sg_host_get_name(process->host));
process->kill_timer = SIMIX_timer_set(kill_time, [=] {
simix_global->kill_process_function(process);
process->kill_timer=nullptr;
});
}
void TRACE_smpi_computing_init(int rank)
{
//first use, initialize the color in the trace
//TODO : check with lucas and Pierre how to generalize this approach
//to avoid unnecessary access to the color array
if (!TRACE_smpi_is_enabled() || !TRACE_smpi_is_computing()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
const char *color = instr_find_color ("computing");
val_t value = PJ_value_get_or_new ("computing", color, type);
new_pajePushState (SIMIX_get_clock(), container, type, value);
}
void TRACE_smpi_recv(int rank, int src, int dst)
{
if (!TRACE_smpi_is_enabled()) return;
char key[INSTR_DEFAULT_STR_SIZE];
bzero (key, INSTR_DEFAULT_STR_SIZE);
TRACE_smpi_get_key(src, dst, key, INSTR_DEFAULT_STR_SIZE);
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(dst, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_LINK", PJ_type_get_root());
new_pajeEndLink (SIMIX_get_clock(), PJ_container_get_root(), type, container, "PTP", key);
}
void new_pajeDestroyContainer (container_t container)
{
paje_event_t event = xbt_new0(s_paje_event_t, 1);
event->event_type = PAJE_DestroyContainer;
event->timestamp = SIMIX_get_clock();
event->print = active_writer.print_DestroyContainer;
event->free = &free_paje_event;
event->data = xbt_new0(s_destroyContainer_t, 1);
(static_cast<destroyContainer_t>(event->data))->container = container;
XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
//print it
event->print (event);
event->free (event);
}
int smpi_gettimeofday(struct timeval *tv)
{
double now;
smpi_bench_end();
now = SIMIX_get_clock();
if (tv) {
tv->tv_sec = (time_t)now;
#ifdef WIN32
tv->tv_usec = (useconds_t)((now - tv->tv_sec) * 1e6);
#else
tv->tv_usec = (suseconds_t)((now - tv->tv_sec) * 1e6);
#endif
}
smpi_bench_begin();
return 0;
}
void new_pajeCreateContainer (container_t container)
{
paje_event_t event = xbt_new0(s_paje_event_t, 1);
event->event_type = PAJE_CreateContainer;
event->timestamp = SIMIX_get_clock();
event->print = active_writer.print_CreateContainer;
event->free = free_paje_event;
event->data = xbt_new0(s_createContainer_t, 1);
((createContainer_t)(event->data))->container = container;
XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
//print it
event->print (event);
event->free (event);
}
void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t synchros, double timeout)
{
smx_activity_t synchro;
unsigned int cursor = 0;
if (MC_is_active() || MC_record_replay_is_active()){
if (timeout > 0.0)
xbt_die("Timeout not implemented for waitany in the model-checker");
int idx = SIMCALL_GET_MC_VALUE(simcall);
synchro = xbt_dynar_get_as(synchros, idx, smx_activity_t);
synchro->simcalls.push_back(simcall);
simcall_comm_waitany__set__result(simcall, idx);
synchro->state = SIMIX_DONE;
SIMIX_comm_finish(synchro);
return;
}
if (timeout < 0.0){
simcall->timer = NULL;
} else {
simcall->timer = SIMIX_timer_set(SIMIX_get_clock() + timeout, [simcall]() {
SIMIX_waitany_remove_simcall_from_actions(simcall);
simcall_comm_waitany__set__result(simcall, -1);
SIMIX_simcall_answer(simcall);
});
}
xbt_dynar_foreach(synchros, cursor, synchro){
/* associate this simcall to the the synchro */
synchro->simcalls.push_back(simcall);
/* see if the synchro is already finished */
if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING){
SIMIX_comm_finish(synchro);
break;
}
}
static time_point now()
{
return time_point(duration(SIMIX_get_clock()));
}
int smpi_main(int (*realmain) (int argc, char *argv[]), int argc, char *argv[])
{
srand(SMPI_RAND_SEED);
if (getenv("SMPI_PRETEND_CC") != NULL) {
/* Hack to ensure that smpicc can pretend to be a simple compiler. Particularly handy to pass it to the
* configuration tools */
return 0;
}
smpi_init_logs();
TRACE_global_init(&argc, argv);
TRACE_add_start_function(TRACE_smpi_alloc);
TRACE_add_end_function(TRACE_smpi_release);
SIMIX_global_init(&argc, argv);
MSG_init(&argc,argv);
SMPI_switch_data_segment = smpi_switch_data_segment;
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_global_init();
smpi_check_options();
if(smpi_privatize_global_variables)
smpi_initialize_global_memory_segments();
/* Clean IO before the run */
fflush(stdout);
fflush(stderr);
if (MC_is_active()) {
MC_run();
} else {
SIMIX_run();
xbt_os_walltimer_stop(global_timer);
if (xbt_cfg_get_boolean("smpi/display-timing")){
double global_time = xbt_os_timer_elapsed(global_timer);
XBT_INFO("Simulated time: %g seconds. \n\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.");
}
}
int count = smpi_process_count();
int i, ret=0;
for (i = 0; i < count; i++) {
if(process_data[i]->return_value!=0){
ret=process_data[i]->return_value;//return first non 0 value
break;
}
}
smpi_global_destroy();
TRACE_end();
return ret;
}
double smpi_process_simulated_elapsed(void)
{
smpi_process_data_t data = smpi_process_data();
return SIMIX_get_clock() - data->simulated;
}
void smpi_process_simulated_start(void)
{
smpi_process_data_t data = smpi_process_data();
data->simulated = SIMIX_get_clock();
}
/** \ingroup msg_simulation
* \brief A clock (in second).
*/
double MSG_get_clock()
{
return SIMIX_get_clock();
}
/** \ingroup msg_simulation
* \brief A clock (in second).
*/
XBT_INLINE double MSG_get_clock(void)
{
return SIMIX_get_clock();
}
double Engine::get_clock()
{
return SIMIX_get_clock();
}
/*
* Time elapsed since the beginning of the simulation.
*/
double xbt_time()
{
/* FIXME: check if we should use the request mechanism or not */
return SIMIX_get_clock();
}