/* 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 "src/surf/surf_interface.hpp"
#include "smx_private.h"
#include "xbt/sysdep.h"
#include "xbt/log.h"
#include "mc/mc.h"
#include "src/mc/mc_replay.h"
#include "src/mc/mc_client.h"
+#include "src/simix/smx_private.hpp"
+#include "src/msg/msg_private.h"
+
+#ifdef HAVE_SMPI
+#include "src/smpi/private.h"
+#endif
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix,
"Logging specific to SIMIX (process)");
/* Unregister from the kill timer if any */
if (process->kill_timer != NULL)
- SIMIX_timer_remove(process->kill_timer);
+ SIMIX_timer_remove(process->kill_timer);
xbt_os_mutex_acquire(simix_global->mutex);
void SIMIX_process_stop(smx_process_t arg) {
/* execute the on_exit functions */
SIMIX_process_on_exit_runall(arg);
- /* Add the process to the list of process to restart, only if
- * the host is down
- */
- if (arg->auto_restart && !sg_host_get_state(arg->host)) {
+ /* Add the process to the list of process to restart, only if the host is down */
+ if (arg->auto_restart && arg->host->is_off()) {
SIMIX_host_add_auto_restart_process(arg->host,arg->name,arg->code, arg->data,
sg_host_get_name(arg->host),
SIMIX_timer_get_date(arg->kill_timer),
XBT_DEBUG("Start process %s on host '%s'", name, hostname);
- if (!sg_host_get_state(host)) {
+ if (host->is_off()) {
int i;
XBT_WARN("Cannot launch process '%s' on failed host '%s'", name,
hostname);
process->data = data;
process->comms = xbt_fifo_new();
process->simcall.issuer = process;
+ /* Initiliaze data segment to default value */
+ SIMIX_segment_index_set(process, -1);
- if (parent_process) {
+ if (parent_process != NULL) {
process->ppid = SIMIX_process_get_PID(parent_process);
+ /* SMPI process have their own data segment and
+ each other inherit from their father */
+#ifdef HAVE_SMPI
+ if(smpi_privatize_global_variables){
+ if( parent_process->pid != 0){
+ SIMIX_segment_index_set(process, parent_process->segment_index);
+ } else {
+ SIMIX_segment_index_set(process, process->pid - 1);
+ }
+ }
+#endif
} else {
process->ppid = -1;
}
sg_host_get_name(process->host), kill_time);
process->kill_timer = SIMIX_timer_set(kill_time, kill_process, process);
}
+
+ /* Tracing the process creation */
+ TRACE_msg_process_create(process->name, process->pid, process->host);
}
return process;
}
case SIMIX_SYNC_EXECUTE:
case SIMIX_SYNC_PARALLEL_EXECUTE:
- SIMIX_process_execution_destroy(process->waiting_synchro);
+ SIMIX_execution_destroy(process->waiting_synchro);
break;
case SIMIX_SYNC_COMMUNICATE:
case SIMIX_SYNC_EXECUTE:
case SIMIX_SYNC_PARALLEL_EXECUTE:
- SIMIX_process_execution_cancel(process->waiting_synchro);
+ SIMIX_execution_cancel(process->waiting_synchro);
break;
case SIMIX_SYNC_COMMUNICATE:
} else {
xbt_fifo_push(sync_suspend->simcalls, simcall);
process->waiting_synchro = sync_suspend;
- SIMIX_host_execution_suspend(process->waiting_synchro);
+ SIMIX_execution_suspend(process->waiting_synchro);
}
/* If we are suspending ourselves, then just do not finish the simcall now */
}
case SIMIX_SYNC_EXECUTE:
case SIMIX_SYNC_PARALLEL_EXECUTE:
- SIMIX_host_execution_suspend(process->waiting_synchro);
+ SIMIX_execution_suspend(process->waiting_synchro);
break;
case SIMIX_SYNC_COMMUNICATE:
}
} else {
/* FIXME: computation size is zero. Is it okay that bound is zero ? */
- return SIMIX_process_execute(process, "suspend", 0.0, 1.0, 0.0, 0);
+ return SIMIX_execution_start(process, "suspend", 0.0, 1.0, 0.0, 0);
}
}
case SIMIX_SYNC_EXECUTE:
case SIMIX_SYNC_PARALLEL_EXECUTE:
- SIMIX_host_execution_resume(process->waiting_synchro);
+ SIMIX_execution_resume(process->waiting_synchro);
break;
case SIMIX_SYNC_COMMUNICATE:
return process->host;
}
+xbt_main_func_t SIMIX_process_get_code(void){
+ return SIMIX_process_self()->code;
+}
+
/* needs to be public and without simcall because it is called
by exceptions and logging events */
const char* SIMIX_process_self_get_name(void) {
smx_process_t process = SIMIX_process_self();
if (process == NULL || process == simix_global->maestro_process)
- return "";
+ return "maestro";
return SIMIX_process_get_name(process);
}
static int SIMIX_process_join_finish(smx_process_exit_status_t status, smx_synchro_t sync){
if (sync->sleep.surf_sleep) {
- surf_action_cancel(sync->sleep.surf_sleep);
+ sync->sleep.surf_sleep->cancel();
smx_simcall_t simcall;
while ((simcall = (smx_simcall_t) xbt_fifo_shift(sync->simcalls))) {
SIMIX_simcall_answer(simcall);
}
}
- surf_action_unref(sync->sleep.surf_sleep);
+ sync->sleep.surf_sleep->unref();
sync->sleep.surf_sleep = NULL;
}
xbt_mallocator_release(simix_global->synchro_mallocator, sync);
sg_host_t host = process->host;
/* check if the host is active */
- if (surf_host_get_state(surf_host_resource_priv(host)) != SURF_RESOURCE_ON) {
+ if (host->is_off()) {
THROWF(host_error, 0, "Host %s failed, you cannot call this function",
sg_host_get_name(host));
}
synchro->sleep.host = host;
synchro->sleep.surf_sleep = surf_host_sleep(host, duration);
- surf_action_set_data(synchro->sleep.surf_sleep, synchro);
+ synchro->sleep.surf_sleep->setData(synchro);
XBT_DEBUG("Create sleep synchronization %p", synchro);
return synchro;
while ((simcall = (smx_simcall_t) xbt_fifo_shift(synchro->simcalls))) {
- switch(surf_action_get_state(synchro->sleep.surf_sleep)){
+ switch (synchro->sleep.surf_sleep->getState()){
case SURF_ACTION_FAILED:
simcall->issuer->context->iwannadie = 1;
//SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
THROW_IMPOSSIBLE;
break;
}
- if (surf_host_get_state(surf_host_resource_priv(simcall->issuer->host)) != SURF_RESOURCE_ON) {
+ if (simcall->issuer->host->is_off()) {
simcall->issuer->context->iwannadie = 1;
}
simcall_process_sleep__set__result(simcall, state);
xbt_assert(synchro->type == SIMIX_SYNC_SLEEP || synchro->type == SIMIX_SYNC_JOIN);
if (synchro->sleep.surf_sleep) {
- surf_action_unref(synchro->sleep.surf_sleep);
+ synchro->sleep.surf_sleep->unref();
synchro->sleep.surf_sleep = NULL;
}
if (synchro->type == SIMIX_SYNC_SLEEP)
void SIMIX_process_sleep_suspend(smx_synchro_t synchro)
{
xbt_assert(synchro->type == SIMIX_SYNC_SLEEP);
- surf_action_suspend(synchro->sleep.surf_sleep);
+ synchro->sleep.surf_sleep->suspend();
}
void SIMIX_process_sleep_resume(smx_synchro_t synchro)
{
XBT_DEBUG("Synchro state is %d on process_sleep_resume.", synchro->state);
xbt_assert(synchro->type == SIMIX_SYNC_SLEEP);
- surf_action_resume(synchro->sleep.surf_sleep);
+ synchro->sleep.surf_sleep->resume();
}
/**
SMX_THROW();
}
+ if(SMPI_switch_data_segment && self->segment_index != -1){
+ SMPI_switch_data_segment(self->segment_index);
+ }
}
/* callback: context fetching */
}
return new_process;
}
+
+void SIMIX_segment_index_set(smx_process_t proc, int index){
+ proc->segment_index = index;
+}