args->code,
args->data,
args->hostname,
+ args->kill_time,
args->argc,
args->argv,
args->properties);
*
* This function actually creates the process.
* It may be called when a SIMCALL_PROCESS_CREATE simcall occurs,
- * or directly for SIMIX internal purposes.
+ * or directly for SIMIX internal purposes. The sure thing is that it's called from maestro context.
*
* \return the process created
*/
xbt_main_func_t code,
void *data,
const char *hostname,
+ double kill_time,
int argc, char **argv,
xbt_dict_t properties) {
XBT_DEBUG("Inserting %s(%s) in the to_run list", (*process)->name, host->name);
xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, *process);
}
+
+ if (kill_time > SIMIX_get_clock()) {
+ if (simix_global->kill_process_function) {
+ XBT_DEBUG("Process %s(%s) will be kill at time %f", (*process)->name,
+ (*process)->smx_host->name, kill_time);
+ SIMIX_timer_set(kill_time, simix_global->kill_process_function, *process);
+ }
+ }
}
/**
void SIMIX_pre_process_suspend(smx_simcall_t simcall)
{
smx_process_t process = simcall->process_suspend.process;
- SIMIX_process_suspend(process, simcall->issuer);
+ smx_action_t action_suspend =
+ SIMIX_process_suspend(process, simcall->issuer);
if (process != simcall->issuer) {
SIMIX_simcall_answer(simcall);
+ } else {
+ xbt_fifo_push(action_suspend->simcalls, simcall);
+ process->waiting_action = action_suspend;
+ SIMIX_host_execution_suspend(process->waiting_action);
}
/* If we are suspending ourselves, then just do not finish the simcall now */
}
-void SIMIX_process_suspend(smx_process_t process, smx_process_t issuer)
+smx_action_t SIMIX_process_suspend(smx_process_t process, smx_process_t issuer)
{
xbt_assert((process != NULL), "Invalid parameters");
if (process->suspended) {
XBT_DEBUG("Process '%s' is already suspended", process->name);
- return;
+ return NULL;
}
process->suspended = 1;
SIMIX_process_sleep_suspend(process->waiting_action);
break;
+ case SIMIX_ACTION_SYNCHRO:
+ /* Suspension is delayed to when the process is rescheduled. */
+ break;
+
default:
xbt_die("Internal error in SIMIX_process_suspend: unexpected action type %d",
(int)process->waiting_action->type);
}
+ return NULL;
+ } else {
+ /* Suspension is delayed to when the process is rescheduled. */
+ return NULL;
}
+ } else {
+ return SIMIX_host_execute("suspend", process->smx_host, 0.0, 1.0);
}
}
{
xbt_assert((process != NULL), "Invalid parameters");
- if(process->context->iwannadie) return;
- process->suspended = 0;
+ XBT_IN("process = %p, issuer = %p", process, issuer);
+
+ if(process->context->iwannadie) {
+ XBT_VERB("Ignoring request to suspend a process that is currently dying.");
+ return;
+ }
+
+ if(!process->suspended) return;
+ process->suspended = 0;
/* If we are resuming another process, resume the action it was waiting for
if any. Otherwise add it to the list of process to run in the next round. */
SIMIX_process_sleep_resume(process->waiting_action);
break;
+ case SIMIX_ACTION_SYNCHRO:
+ /* I cannot resume it now. This is delayed to when the process is rescheduled at
+ * the end of the synchro. */
+ break;
+
default:
xbt_die("Internal error in SIMIX_process_resume: unexpected action type %d",
(int)process->waiting_action->type);
}
}
- else {
- if(!xbt_dynar_member(simix_global->process_to_run, &(process)))
- xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, process);
- }
- }
+ } else XBT_WARN("Strange. Process %p is trying to resume himself.", issuer);
+
+ XBT_OUT();
}
int SIMIX_process_get_maxpid(void) {
SIMIX_context_stop(self->context);
}
+ if(self->suspended) {
+ xbt_assert(!self->doexception, "Gloups! This exception may be lost by subsequent calls.");
+ self->suspended = 0;
+ SIMIX_process_suspend(self,self);
+ }
+
if (self->doexception) {
XBT_DEBUG("Wait, maestro left me an exception");
self->doexception = 0;