add_executable(masterslave_virtual_machines "masterslave_virtual_machines.c")
add_executable(simple_vm "simple_vm.c")
add_executable(migrate_vm "migrate_vm.c")
+add_executable(bound "bound.c")
### Add definitions for compile
target_link_libraries(masterslave_virtual_machines simgrid)
target_link_libraries(simple_vm simgrid)
target_link_libraries(migrate_vm simgrid)
+target_link_libraries(bound simgrid)
set(tesh_files
${tesh_files}
${CMAKE_CURRENT_SOURCE_DIR}/masterslave_virtual_machines.c
${CMAKE_CURRENT_SOURCE_DIR}/simple_vm.c
${CMAKE_CURRENT_SOURCE_DIR}/migrate_vm.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/bound.c
PARENT_SCOPE
)
set(bin_files
MSG_init(&argc, argv);
/* load the platform file */
+ xbt_assert(argc == 2);
MSG_create_environment(argv[1]);
xbt_dynar_t hosts_dynar = MSG_hosts_as_dynar();
XBT_PUBLIC(msg_error_t) MSG_task_execute(msg_task_t task);
XBT_PUBLIC(msg_error_t) MSG_parallel_task_execute(msg_task_t task);
XBT_PUBLIC(void) MSG_task_set_priority(msg_task_t task, double priority);
+XBT_PUBLIC(void) MSG_task_set_bound(msg_task_t task, double bound);
XBT_PUBLIC(msg_error_t) MSG_process_sleep(double nb_sec);
XBT_PUBLIC(smx_action_t) simcall_host_execute(const char *name, smx_host_t host,
double computation_amount,
- double priority);
+ double priority, double bound);
XBT_PUBLIC(smx_action_t) simcall_host_parallel_execute(const char *name,
int host_nb,
smx_host_t *host_list,
XBT_PUBLIC(double) simcall_host_execution_get_remains(smx_action_t execution);
XBT_PUBLIC(e_smx_state_t) simcall_host_execution_get_state(smx_action_t execution);
XBT_PUBLIC(void) simcall_host_execution_set_priority(smx_action_t execution, double priority);
+XBT_PUBLIC(void) simcall_host_execution_set_bound(smx_action_t execution, double bound);
XBT_PUBLIC(e_smx_state_t) simcall_host_execution_wait(smx_action_t execution);
XBT_PUBLIC(void) simcall_host_get_params(smx_host_t vm, ws_params_t param);
XBT_PUBLIC(void) simcall_host_set_params(smx_host_t vm, ws_params_t param);
xbt_swag_t state_set;
double cost; /**< cost */
double priority; /**< priority (1.0 by default) */
+ double bound; /**< the capping of the CPU use */
double max_duration; /**< max_duration (may fluctuate until
the task is completed) */
double remains; /**< How much of that cost remains to
int (*is_suspended) (surf_action_t action); /**< Return whether an action is suspended */
void (*set_max_duration) (surf_action_t action, double duration); /**< Set the max duration of an action*/
void (*set_priority) (surf_action_t action, double priority); /**< Set the priority of an action */
+ void (*set_bound) (surf_action_t action, double bound); /**< Set the bound (the maximum CPU utilization) of an action */
#ifdef HAVE_TRACING
void (*set_category) (surf_action_t action, const char *category); /**< Set the category of an action */
#endif
simdata->compute = simcall_host_execute(task->name,
p_simdata->m_host,
simdata->computation_amount,
- simdata->priority);
+ simdata->priority,
+ simdata->bound);
}
#ifdef HAVE_TRACING
msg_process_t receiver;
msg_host_t source;
double priority;
- double rate;
+ double bound; /* Capping for CPU resource */
+ double rate; /* Capping for network resource */
int isused; /* Indicates whether the task is used in SIMIX currently */
int host_nb; /* ==0 if sequential task; parallel task if not */
/******* Parallel Tasks Only !!!! *******/
simdata->receiver = NULL;
simdata->source = NULL;
simdata->priority = 1.0;
+ simdata->bound = 0;
simdata->rate = -1.0;
simdata->isused = 0;
simcall_host_execution_set_priority(task->simdata->compute,
task->simdata->priority);
}
+
+
+/** \ingroup m_task_management
+ * \brief Changes the maximum CPU utilization of a computation task.
+ * Unit is flops/s.
+ *
+ */
+void MSG_task_set_bound(msg_task_t task, double bound)
+{
+ xbt_assert(task, "Invalid parameter");
+ xbt_assert(task->simdata, "Invalid parameter");
+
+ if (bound == 0)
+ XBT_INFO("bound == 0 means no capping");
+
+ task->simdata->bound = bound;
+ if (task->simdata->compute)
+ simcall_host_execution_set_bound(task->simdata->compute,
+ task->simdata->bound);
+}
}
smx_action_t SIMIX_pre_host_execute(smx_simcall_t simcall,const char *name,
- smx_host_t host, double computation_amount, double priority){
- return SIMIX_host_execute(name, host, computation_amount, priority);
+ smx_host_t host, double computation_amount, double priority, double bound){
+ return SIMIX_host_execute(name, host, computation_amount, priority, bound);
}
smx_action_t SIMIX_host_execute(const char *name,
- smx_host_t host, double computation_amount, double priority){
+ smx_host_t host, double computation_amount, double priority, double bound){
/* alloc structures and initialize */
smx_action_t action = xbt_mallocator_get(simix_global->action_mallocator);
action->execution.surf_exec = ws_model->extension.workstation.execute(host, computation_amount);
ws_model->action_data_set(action->execution.surf_exec, action);
ws_model->set_priority(action->execution.surf_exec, priority);
+ ws_model->set_bound(action->execution.surf_exec, bound);
}
XBT_DEBUG("Create execute action %p", action);
void SIMIX_pre_host_execution_set_priority(smx_simcall_t simcall, smx_action_t action,
double priority){
- return SIMIX_host_execution_set_priority(action, priority);
+ SIMIX_host_execution_set_priority(action, priority);
}
void SIMIX_host_execution_set_priority(smx_action_t action, double priority){
surf_model_t ws_model = get_ws_model_from_action(action);
ws_model->set_priority(action->execution.surf_exec, priority);
}
+void SIMIX_pre_host_execution_set_bound(smx_simcall_t simcall, smx_action_t action,
+ double bound){
+ SIMIX_host_execution_set_bound(action, bound);
+}
+void SIMIX_host_execution_set_bound(smx_action_t action, double bound){
+ surf_model_t ws_model = get_ws_model_from_action(action);
+
+ if(action->execution.surf_exec)
+ ws_model->set_bound(action->execution.surf_exec, bound);
+}
+
void SIMIX_pre_host_execution_wait(smx_simcall_t simcall, smx_action_t action){
XBT_DEBUG("Wait for execution of action %p, state %d", action, (int)action->state);
double SIMIX_host_get_available_speed(smx_host_t host);
int SIMIX_host_get_state(smx_host_t host);
smx_action_t SIMIX_host_execute(const char *name,
- smx_host_t host, double computation_amount, double priority);
+ smx_host_t host, double computation_amount, double priority, double bound);
smx_action_t SIMIX_host_parallel_execute(const char *name,
int host_nb, smx_host_t *host_list,
double *computation_amount, double *communication_amount,
double SIMIX_host_execution_get_remains(smx_action_t action);
e_smx_state_t SIMIX_host_execution_get_state(smx_action_t action);
void SIMIX_host_execution_set_priority(smx_action_t action, double priority);
+void SIMIX_host_execution_set_bound(smx_action_t action, double bound);
void SIMIX_pre_host_execution_wait(smx_simcall_t simcall, smx_action_t action);
// pre prototypes
void* SIMIX_pre_host_self_get_data(smx_simcall_t);
void* SIMIX_pre_host_get_data(smx_simcall_t, smx_host_t);
void SIMIX_pre_host_set_data(smx_simcall_t, smx_host_t, void*);
-smx_action_t SIMIX_pre_host_execute(smx_simcall_t, const char*, smx_host_t, double, double);
+smx_action_t SIMIX_pre_host_execute(smx_simcall_t, const char*, smx_host_t, double, double, double);
smx_action_t SIMIX_pre_host_parallel_execute(smx_simcall_t, const char*, int, smx_host_t*,
double*, double*, double, double);
void SIMIX_pre_host_execution_destroy(smx_simcall_t, smx_action_t);
return NULL;
}
} else {
- return SIMIX_host_execute("suspend", process->smx_host, 0.0, 1.0);
+ /* FIXME: computation size is zero. Is it okay that bound is zero ? */
+ return SIMIX_host_execute("suspend", process->smx_host, 0.0, 1.0, 0.0);
}
}
ACTION(SIMCALL_HOST_GET_STATE, host_get_state, WITH_ANSWER, TINT(result), TSPEC(host, smx_host_t)) sep \
ACTION(SIMCALL_HOST_GET_DATA, host_get_data, WITH_ANSWER, TPTR(result), TSPEC(host, smx_host_t)) sep \
ACTION(SIMCALL_HOST_SET_DATA, host_set_data, WITH_ANSWER, TVOID(result), TSPEC(host, smx_host_t), TPTR(data)) sep \
-ACTION(SIMCALL_HOST_EXECUTE, host_execute, WITH_ANSWER, TSPEC(result, smx_action_t), TSTRING(name), TSPEC(host, smx_host_t), TDOUBLE(computation_amount), TDOUBLE(priority)) sep \
+ACTION(SIMCALL_HOST_EXECUTE, host_execute, WITH_ANSWER, TSPEC(result, smx_action_t), TSTRING(name), TSPEC(host, smx_host_t), TDOUBLE(computation_amount), TDOUBLE(priority), TDOUBLE(bound)) sep \
ACTION(SIMCALL_HOST_PARALLEL_EXECUTE, host_parallel_execute, WITH_ANSWER, TSPEC(result, smx_action_t), TSTRING(name), TINT(host_nb), TSPEC(host_list, smx_host_t*), TSPEC(computation_amount, double*), TSPEC(communication_amount, double*), TDOUBLE(amount), TDOUBLE(rate)) sep \
ACTION(SIMCALL_HOST_EXECUTION_DESTROY, host_execution_destroy, WITH_ANSWER, TVOID(result), TSPEC(execution, smx_action_t)) sep \
ACTION(SIMCALL_HOST_EXECUTION_CANCEL, host_execution_cancel, WITH_ANSWER, TVOID(result), TSPEC(execution, smx_action_t)) sep \
ACTION(SIMCALL_HOST_EXECUTION_GET_REMAINS, host_execution_get_remains, WITH_ANSWER, TDOUBLE(result), TSPEC(execution, smx_action_t)) sep \
ACTION(SIMCALL_HOST_EXECUTION_GET_STATE, host_execution_get_state, WITH_ANSWER, TINT(result), TSPEC(execution, smx_action_t)) sep \
ACTION(SIMCALL_HOST_EXECUTION_SET_PRIORITY, host_execution_set_priority, WITH_ANSWER, TVOID(result), TSPEC(execution, smx_action_t), TDOUBLE(priority)) sep \
+ACTION(SIMCALL_HOST_EXECUTION_SET_BOUND, host_execution_set_bound, WITHOUT_ANSWER, TVOID(result), TSPEC(execution, smx_action_t), TDOUBLE(bound)) sep \
ACTION(SIMCALL_HOST_EXECUTION_WAIT, host_execution_wait, WITHOUT_ANSWER, TINT(result), TSPEC(execution, smx_action_t)) sep \
ACTION(SIMCALL_HOST_GET_PARAMS, host_get_params, WITHOUT_ANSWER, TVOID(result), TSPEC(ind_vm, smx_host_t), TSPEC(params, ws_params_t)) sep \
ACTION(SIMCALL_HOST_SET_PARAMS, host_set_params, WITHOUT_ANSWER, TVOID(result), TSPEC(ind_vm, smx_host_t), TSPEC(params, ws_params_t)) sep \
smx_action_t simcall_host_execute(const char *name, smx_host_t host,
double computation_amount,
- double priority)
+ double priority, double bound)
{
/* checking for infinite values */
xbt_assert(isfinite(computation_amount), "computation_amount is not finite!");
xbt_assert(isfinite(priority), "priority is not finite!");
- return simcall_BODY_host_execute(name, host, computation_amount, priority);
+ return simcall_BODY_host_execute(name, host, computation_amount, priority, bound);
}
/**
simcall_BODY_host_execution_set_priority(execution, priority);
}
+/**
+ * \ingroup simix_host_management
+ * \brief Changes the capping (the maximum CPU utilization) of an execution action.
+ *
+ * This functions changes the capping only. It calls a surf function.
+ * \param execution The execution action
+ * \param bound The new bound
+ */
+void simcall_host_execution_set_bound(smx_action_t execution, double bound)
+{
+ simcall_BODY_host_execution_set_bound(execution, bound);
+}
+
/**
* \ingroup simix_host_management
* \brief Waits for the completion of an execution action and destroy it.
cpu_model->is_suspended = surf_action_is_suspended;
cpu_model->set_max_duration = surf_action_set_max_duration;
cpu_model->set_priority = surf_action_set_priority;
+ cpu_model->set_bound = surf_action_set_bound;
#ifdef HAVE_TRACING
cpu_model->set_category = surf_action_set_category;
#endif
XBT_OUT();
}
+void surf_action_set_bound(surf_action_t action, double bound)
+{
+ surf_model_t model = action->model_obj;
+ XBT_IN("(%p,%g)", action, bound);
+ action->bound = bound;
+ lmm_update_variable_bound(model->model_private->maxmin_system, ((surf_action_lmm_t) action)->variable, bound);
+
+ if (model->model_private->update_mechanism == UM_LAZY)
+ surf_action_lmm_heap_remove(model->model_private->action_heap, (surf_action_lmm_t) action);
+ XBT_OUT();
+}
+
#ifdef HAVE_TRACING
void surf_action_set_category(surf_action_t action,
const char *category)
int surf_action_is_suspended(surf_action_t action);
void surf_action_set_max_duration(surf_action_t action, double duration);
void surf_action_set_priority(surf_action_t action, double priority);
+void surf_action_set_bound(surf_action_t action, double bound);
#ifdef HAVE_TRACING
void surf_action_set_category(surf_action_t action,
const char *category);
// model->is_suspended = ws_action_is_suspended;
// model->set_max_duration = ws_action_set_max_duration;
model->set_priority = ws_action_set_priority;
+ model->set_bound = ws_action_set_bound;
// #ifdef HAVE_TRACING
// model->set_category = ws_action_set_category;
// #endif
model->extension.workstation.execute = vm_ws_execute;
model->extension.workstation.sleep = ws_action_sleep;
model->extension.workstation.get_state = ws_get_state;
- // model->extension.workstation.get_speed = ws_get_speed;
+ model->extension.workstation.get_speed = ws_get_speed;
// model->extension.workstation.get_available_speed = ws_get_available_speed;
// model->extension.workstation.communicate = ws_communicate;
DIE_IMPOSSIBLE;
}
+void ws_action_set_bound(surf_action_t action, double bound)
+{
+ /* FIXME: only for CPU model object? */
+ if (action->model_obj->type == SURF_MODEL_TYPE_NETWORK)
+ surf_network_model->set_bound(action, bound);
+ else if (action->model_obj->type == SURF_MODEL_TYPE_CPU)
+ action->model_obj->set_bound(action, bound);
+ else
+ DIE_IMPOSSIBLE;
+}
+
#ifdef HAVE_TRACING
static void ws_action_set_category(surf_action_t action, const char *category)
{
return cpu->model->extension.cpu.get_state(workstation);
}
-static double ws_get_speed(void *workstation, double load)
+double ws_get_speed(void *workstation, double load)
{
surf_resource_t cpu = ((surf_resource_t) surf_cpu_resource_priv(workstation));
return cpu->model->extension.cpu.get_speed(workstation, load);
model->is_suspended = ws_action_is_suspended;
model->set_max_duration = ws_action_set_max_duration;
model->set_priority = ws_action_set_priority;
+ model->set_bound = ws_action_set_bound;
#ifdef HAVE_TRACING
model->set_category = ws_action_set_category;
#endif
void ws_finalize(surf_model_t workstation_model);
void ws_action_set_priority(surf_action_t action, double priority);
+void ws_action_set_bound(surf_action_t action, double bound);
surf_action_t ws_execute(void *workstation, double size);
surf_action_t ws_action_sleep(void *workstation, double duration);
void ws_action_resume(surf_action_t action);
void ws_action_cancel(surf_action_t action);
e_surf_resource_state_t ws_get_state(void *workstation);
+double ws_get_speed(void *workstation, double load);
double ws_action_get_remains(surf_action_t action);
void ws_get_params(void *ws, ws_params_t params);