double scale,
double shape);
-static inline char* sg_host_name(sg_host_t host) {
- return host->key;
-}
-
typedef xbt_dictelm_t sg_storage_t;
static inline char* sg_storage_name(sg_storage_t storage) {
return storage->key;
/*********************************** Host *************************************/
XBT_PUBLIC(sg_host_t) SIMIX_host_self(void);
XBT_PUBLIC(const char*) SIMIX_host_self_get_name(void);
-#define SIMIX_host_get_name(h) sg_host_name(h) /* DEPRECATED: SIMIX_host_get_name */
+#define SIMIX_host_get_name(h) sg_host_get_name(h) /* DEPRECATED: SIMIX_host_get_name */
XBT_PUBLIC(void) SIMIX_host_on(sg_host_t host);
XBT_PUBLIC(void) SIMIX_host_off(sg_host_t host, smx_process_t issuer);
XBT_PUBLIC(void) SIMIX_host_self_set_data(void *data);
/* Let's create the process: SIMIX may decide to start it right now,
* even before returning the flow control to us */
- process = simcall_process_create(name, code, simdata, sg_host_name(host), -1,
+ process = simcall_process_create(name, code, simdata, sg_host_get_name(host), -1,
argc, argv, properties,0);
TRACE_msg_process_create(name, SIMIX_process_get_PID(process), host);
void MSG_vm_destroy(msg_vm_t vm)
{
if (MSG_vm_is_migrating(vm))
- THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_name(vm));
+ THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_get_name(vm));
/* First, terminate all processes on the VM if necessary */
if (MSG_vm_is_running(vm))
* migration. The names of these mailboxes must not conflict with others. */
static inline char *get_mig_mbox_src_dst(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
{
- char *vm_name = sg_host_name(vm);
- char *src_pm_name = sg_host_name(src_pm);
- char *dst_pm_name = sg_host_name(dst_pm);
+ char *vm_name = sg_host_get_name(vm);
+ char *src_pm_name = sg_host_get_name(src_pm);
+ char *dst_pm_name = sg_host_get_name(dst_pm);
return bprintf("__mbox_mig_src_dst:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
}
static inline char *get_mig_mbox_ctl(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
{
- char *vm_name = sg_host_name(vm);
- char *src_pm_name = sg_host_name(src_pm);
- char *dst_pm_name = sg_host_name(dst_pm);
+ char *vm_name = sg_host_get_name(vm);
+ char *src_pm_name = sg_host_get_name(src_pm);
+ char *dst_pm_name = sg_host_get_name(dst_pm);
return bprintf("__mbox_mig_ctl:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
}
static inline char *get_mig_process_tx_name(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
{
- char *vm_name = sg_host_name(vm);
- char *src_pm_name = sg_host_name(src_pm);
- char *dst_pm_name = sg_host_name(dst_pm);
+ char *vm_name = sg_host_get_name(vm);
+ char *src_pm_name = sg_host_get_name(src_pm);
+ char *dst_pm_name = sg_host_get_name(dst_pm);
return bprintf("__pr_mig_tx:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
}
static inline char *get_mig_process_rx_name(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
{
- char *vm_name = sg_host_name(vm);
- char *src_pm_name = sg_host_name(src_pm);
- char *dst_pm_name = sg_host_name(dst_pm);
+ char *vm_name = sg_host_get_name(vm);
+ char *src_pm_name = sg_host_get_name(src_pm);
+ char *dst_pm_name = sg_host_get_name(dst_pm);
return bprintf("__pr_mig_rx:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
}
static inline char *get_mig_task_name(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm, int stage)
{
- char *vm_name = sg_host_name(vm);
- char *src_pm_name = sg_host_name(src_pm);
- char *dst_pm_name = sg_host_name(dst_pm);
+ char *vm_name = sg_host_get_name(vm);
+ char *src_pm_name = sg_host_get_name(src_pm);
+ char *dst_pm_name = sg_host_get_name(dst_pm);
return bprintf("__task_mig_stage%d:%s(%s-%s)", stage, vm_name, src_pm_name, dst_pm_name);
}
double duration = clock - dp->prev_clock;
XBT_DEBUG("%s@%s: computed %f ops (remaining %f -> %f) in %f secs (%f -> %f)",
- key, sg_host_name(vm), computed, dp->prev_remaining, remaining, duration, dp->prev_clock, clock);
+ key, sg_host_get_name(vm), computed, dp->prev_remaining, remaining, duration, dp->prev_clock, clock);
return computed;
}
xbt_assert(xbt_dict_get_or_null(priv->dp_objs, key) == NULL);
xbt_dict_set(priv->dp_objs, key, dp, NULL);
- XBT_DEBUG("add %s on %s (remaining %f, dp_enabled %d)", key, sg_host_name(host), remaining, priv->dp_enabled);
+ XBT_DEBUG("add %s on %s (remaining %f, dp_enabled %d)", key, sg_host_get_name(host), remaining, priv->dp_enabled);
xbt_free(key);
}
xbt_dict_remove(priv->dp_objs, key);
xbt_free(dp);
- XBT_DEBUG("del %s on %s", key, sg_host_name(host));
+ XBT_DEBUG("del %s on %s", key, sg_host_get_name(host));
xbt_free(key);
}
if(ret == MSG_HOST_FAILURE){
//XBT_INFO("SRC host failed during migration of %s (stage %d)", sg_host_name(vm), stage);
MSG_task_destroy(task);
- THROWF(host_error, 0, "SRC host failed during migration of %s (stage %d)", sg_host_name(vm), stage);
+ THROWF(host_error, 0, "SRC host failed during migration of %s (stage %d)", sg_host_get_name(vm), stage);
}else if(ret == MSG_TRANSFER_FAILURE){
//XBT_INFO("DST host failed during migration of %s (stage %d)", sg_host_name(vm), stage);
MSG_task_destroy(task);
- THROWF(host_error, 0, "DST host failed during migration of %s (stage %d)", sg_host_name(vm), stage);
+ THROWF(host_error, 0, "DST host failed during migration of %s (stage %d)", sg_host_get_name(vm), stage);
}
double clock_end = MSG_get_clock();
msg_host_t old_pm = simcall_vm_get_pm(vm);
if(MSG_host_is_off(old_pm))
- THROWF(vm_error, 0, "SRC host(%s) seems off, cannot start a migration", sg_host_name(old_pm));
+ THROWF(vm_error, 0, "SRC host(%s) seems off, cannot start a migration", sg_host_get_name(old_pm));
if(MSG_host_is_off(new_pm))
- THROWF(vm_error, 0, "DST host(%s) seems off, cannot start a migration", sg_host_name(new_pm));
+ THROWF(vm_error, 0, "DST host(%s) seems off, cannot start a migration", sg_host_get_name(new_pm));
if (!MSG_vm_is_running(vm))
- THROWF(vm_error, 0, "VM(%s) is not running", sg_host_name(vm));
+ THROWF(vm_error, 0, "VM(%s) is not running", sg_host_get_name(vm));
if (MSG_vm_is_migrating(vm))
- THROWF(vm_error, 0, "VM(%s) is already migrating", sg_host_name(vm));
+ THROWF(vm_error, 0, "VM(%s) is already migrating", sg_host_get_name(vm));
msg_host_priv_t priv = sg_host_msg(vm);
priv->is_migrating = 1;
void MSG_vm_suspend(msg_vm_t vm)
{
if (MSG_vm_is_migrating(vm))
- THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_name(vm));
+ THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_get_name(vm));
simcall_vm_suspend(vm);
void MSG_vm_save(msg_vm_t vm)
{
if (MSG_vm_is_migrating(vm))
- THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_name(vm));
+ THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_get_name(vm));
simcall_vm_save(vm);
TRACE_msg_vm_save(vm);
}
s4u::Host *s4u::Actor::getHost() {
- return s4u::Host::byName(sg_host_name(simcall_process_get_host(p_smx_process)));
+ return s4u::Host::byName(sg_host_get_name(simcall_process_get_host(p_smx_process)));
}
const char* s4u::Actor::getName() {
return simcall_process_get_name(p_smx_process);
if (smx_proc == NULL)
xbt_die("Cannot call Host::current() from the maestro context");
- return Host::byName(SIMIX_host_get_name(SIMIX_process_get_host(smx_proc)));
+ return Host::byName(sg_host_get_name(SIMIX_process_get_host(smx_proc)));
}
const char* Host::name() {
- return sg_host_name(p_inferior);
+ return sg_host_get_name(p_inferior);
}
void Host::turnOn() {
*/
const char *SD_workstation_get_name(SD_workstation_t workstation)
{
- return sg_host_name(workstation);
+ return sg_host_get_name(workstation);
}
/**
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_name(process->host));
+ sg_host_get_name(process->host));
process->kill_timer = SIMIX_timer_set(kill_time, simix_global->kill_process_function, process);
}
}
arg = xbt_new0(s_smx_process_arg_t, 1);
arg->code = parse_code;
arg->data = NULL;
- arg->hostname = sg_host_name(host);
+ arg->hostname = sg_host_get_name(host);
arg->argc = process->argc;
arg->argv = xbt_new(char *,process->argc);
int i;
arg->name = (char*)(process->argv)[0];
arg->code = parse_code;
arg->data = NULL;
- arg->hostname = sg_host_name(host);
+ arg->hostname = sg_host_get_name(host);
arg->argc = process->argc;
arg->argv = (char**)(process->argv);
arg->kill_time = kill_time;
arg->hostname, start_time);
SIMIX_timer_set(start_time, &SIMIX_process_create_from_wrapper, arg);
} else { // start_time <= SIMIX_get_clock()
- XBT_DEBUG("Starting Process %s(%s) right now", process->argv[0], sg_host_name(host));
+ XBT_DEBUG("Starting Process %s(%s) right now", process->argv[0], sg_host_get_name(host));
if (simix_global->create_process_function)
process_created = simix_global->create_process_function(
(char*)(process->argv)[0],
parse_code,
NULL,
- sg_host_name(host),
+ sg_host_get_name(host),
kill_time,
process->argc,
(char**)(process->argv),
current_property_set,
auto_restart, NULL);
else
- process_created = simcall_process_create((char*)(process->argv)[0], parse_code, NULL, sg_host_name(host), kill_time, process->argc,
+ process_created = simcall_process_create((char*)(process->argv)[0], parse_code, NULL, sg_host_get_name(host), kill_time, process->argc,
(char**)process->argv, current_property_set,auto_restart);
/* verify if process has been created (won't be the case if the host is currently dead, but that's fine) */
sg_host_t host = sg_host_by_name(process_host);
if (!host)
THROWF(arg_error, 0, "Host '%s' unknown", process_host);
- process.host = sg_host_name(host);
+ process.host = sg_host_get_name(host);
process.argc = 1 + xbt_dynar_length(arguments);
process.argv = (const char**)xbt_new(char *, process.argc + 1);
break;
}
XBT_INFO("Process %lu (%s@%s): waiting for %s synchro %p (%s) in state %d to finish",
- process->pid, process->name, sg_host_name(process->host),
+ process->pid, process->name, sg_host_get_name(process->host),
synchro_description, process->waiting_synchro,
process->waiting_synchro->name, (int)process->waiting_synchro->state);
}
else {
- XBT_INFO("Process %lu (%s@%s)", process->pid, process->name, sg_host_name(process->host));
+ XBT_INFO("Process %lu (%s@%s)", process->pid, process->name, sg_host_get_name(process->host));
}
}
}
smx_process_t process = NULL;
xbt_swag_foreach(process, host->process_list) {
SIMIX_process_kill(process, issuer);
- XBT_DEBUG("Killing %s on %s by %s", process->name, sg_host_name(process->host), issuer->name);
+ XBT_DEBUG("Killing %s on %s by %s", process->name, sg_host_get_name(process->host), issuer->name);
}
}
}
arg->auto_restart = auto_restart;
if( sg_host_get_state(host) == SURF_RESOURCE_OFF
- && !xbt_dict_get_or_null(watched_hosts_lib,sg_host_name(host))){
- xbt_dict_set(watched_hosts_lib,sg_host_name(host),host,NULL);
- XBT_DEBUG("Have pushed host %s to watched_hosts_lib because state == SURF_RESOURCE_OFF",sg_host_name(host));
+ && !xbt_dict_get_or_null(watched_hosts_lib,sg_host_get_name(host))){
+ xbt_dict_set(watched_hosts_lib,sg_host_get_name(host),host,NULL);
+ XBT_DEBUG("Have pushed host %s to watched_hosts_lib because state == SURF_RESOURCE_OFF",sg_host_get_name(host));
}
xbt_dynar_push_as(sg_host_simix(host)->auto_restart_processes,smx_process_arg_t,arg);
}
break;
case SIMIX_FAILED:
- XBT_DEBUG("SIMIX_execution_finished: host '%s' failed", sg_host_name(simcall->issuer->host));
+ XBT_DEBUG("SIMIX_execution_finished: host '%s' failed", sg_host_get_name(simcall->issuer->host));
simcall->issuer->context->iwannadie = 1;
SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
break;
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "smx_private.h"
-//#include "surf/storage_private.h"
#include "xbt/sysdep.h"
#include "xbt/log.h"
#include "xbt/dict.h"
/* check if the host is active */
if (surf_host_get_state(surf_host_resource_priv(host)) != SURF_RESOURCE_ON) {
THROWF(host_error, 0, "Host %s failed, you cannot call this function",
- sg_host_name(host));
+ sg_host_get_name(host));
}
synchro = xbt_mallocator_get(simix_global->synchro_mallocator);
/* check if the host is active */
if (surf_host_get_state(surf_host_resource_priv(host)) != SURF_RESOURCE_ON) {
THROWF(host_error, 0, "Host %s failed, you cannot call this function",
- sg_host_name(host));
+ sg_host_get_name(host));
}
synchro = xbt_mallocator_get(simix_global->synchro_mallocator);
/* check if the host is active */
if (surf_host_get_state(surf_host_resource_priv(host)) != SURF_RESOURCE_ON) {
THROWF(host_error, 0, "Host %s failed, you cannot call this function",
- sg_host_name(host));
+ sg_host_get_name(host));
}
synchro = xbt_mallocator_get(simix_global->synchro_mallocator);
/* check if the host is active */
if (surf_host_get_state(surf_host_resource_priv(host)) != SURF_RESOURCE_ON) {
THROWF(host_error, 0, "Host %s failed, you cannot call this function",
- sg_host_name(host));
+ sg_host_get_name(host));
}
synchro = xbt_mallocator_get(simix_global->synchro_mallocator);
/* check if the host is active */
if (surf_host_get_state(surf_host_resource_priv(host)) != SURF_RESOURCE_ON) {
THROWF(host_error, 0, "Host %s failed, you cannot call this function",
- sg_host_name(host));
+ sg_host_get_name(host));
}
int res = surf_host_unlink(host, fd->surf_file);
XBT_DEBUG("Link failure in synchro %p between '%s' and '%s': posting an exception to the issuer: %s (%p) detached:%d",
synchro,
- synchro->comm.src_proc ? sg_host_name(synchro->comm.src_proc->host) : NULL,
- synchro->comm.dst_proc ? sg_host_name(synchro->comm.dst_proc->host) : NULL,
+ synchro->comm.src_proc ? sg_host_get_name(synchro->comm.src_proc->host) : NULL,
+ synchro->comm.dst_proc ? sg_host_get_name(synchro->comm.dst_proc->host) : NULL,
simcall->issuer->name, simcall->issuer, synchro->comm.detached);
if (synchro->comm.src_proc == simcall->issuer) {
XBT_DEBUG("I'm source");
XBT_DEBUG("Copying comm %p data from %s (%p) -> %s (%p) (%zu bytes)",
comm,
- comm->comm.src_proc ? sg_host_name(comm->comm.src_proc->host) : "a finished process",
+ comm->comm.src_proc ? sg_host_get_name(comm->comm.src_proc->host) : "a finished process",
comm->comm.src_buff,
- comm->comm.dst_proc ? sg_host_name(comm->comm.dst_proc->host) : "a finished process",
+ comm->comm.dst_proc ? sg_host_get_name(comm->comm.dst_proc->host) : "a finished process",
comm->comm.dst_buff, buff_size);
/* Copy at most dst_buff_size bytes of the message to receiver's buffer */
*/
if (arg->auto_restart && !sg_host_get_state(arg->host)) {
SIMIX_host_add_auto_restart_process(arg->host,arg->name,arg->code, arg->data,
- sg_host_name(arg->host),
+ sg_host_get_name(arg->host),
SIMIX_timer_get_date(arg->kill_timer),
arg->argc,arg->argv,arg->properties,
arg->auto_restart);
}
- XBT_DEBUG("Process %s (%s) is dead",arg->name,sg_host_name(arg->host));
+ XBT_DEBUG("Process %s (%s) is dead",arg->name,sg_host_get_name(arg->host));
/* stop the context */
SIMIX_context_stop(arg->context);
}
/* Now insert it in the global process list and in the process to run list */
xbt_swag_insert(process, simix_global->process_list);
- XBT_DEBUG("Inserting %s(%s) in the to_run list", process->name, sg_host_name(host));
+ XBT_DEBUG("Inserting %s(%s) in the to_run list", process->name, sg_host_get_name(host));
xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, process);
if (kill_time > SIMIX_get_clock() && simix_global->kill_process_function) {
XBT_DEBUG("Process %s(%s) will be kill at time %f", process->name,
- sg_host_name(process->host), kill_time);
+ sg_host_get_name(process->host), kill_time);
process->kill_timer = SIMIX_timer_set(kill_time, simix_global->kill_process_function, process);
}
}
*/
void SIMIX_process_kill(smx_process_t process, smx_process_t issuer) {
- XBT_DEBUG("Killing process %s on %s", process->name, sg_host_name(process->host));
+ XBT_DEBUG("Killing process %s on %s", process->name, sg_host_get_name(process->host));
process->context->iwannadie = 1;
process->blocked = 0;
/* check if the host is active */
if (surf_host_get_state(surf_host_resource_priv(host)) != SURF_RESOURCE_ON) {
THROWF(host_error, 0, "Host %s failed, you cannot call this function",
- sg_host_name(host));
+ sg_host_get_name(host));
}
synchro = xbt_mallocator_get(simix_global->synchro_mallocator);
}
/** @brief Restart a process, starting it again from the beginning. */
smx_process_t SIMIX_process_restart(smx_process_t process, smx_process_t issuer) {
- XBT_DEBUG("Restarting process %s on %s", process->name, sg_host_name(process->host));
+ XBT_DEBUG("Restarting process %s on %s", process->name, sg_host_get_name(process->host));
//retrieve the arguments of the old process
//FIXME: Factorize this with SIMIX_host_add_auto_restart_process ?
s_smx_process_arg_t arg;
arg.code = process->code;
- arg.hostname = sg_host_name(process->host);
+ arg.hostname = sg_host_get_name(process->host);
arg.kill_time = SIMIX_timer_get_date(process->kill_timer);
arg.argc = process->argc;
arg.data = process->data;