return simcall_vm_get_state(vm) == state;
}
-/** @brief Returns whether the given VM has just reated, not running.
+/** @brief Returns whether the given VM has just created, not running.
* @ingroup msg_VMs
*/
int MSG_vm_is_created(msg_vm_t vm)
* All parameters are in MBytes
*
*/
-msg_vm_t MSG_vm_create(msg_host_t ind_pm, const char *name, int ncpus, int ramsize,
- int net_cap, char *disk_path, int disksize,
- int mig_netspeed, int dp_intensity)
+msg_vm_t MSG_vm_create(msg_host_t ind_pm, const char *name,
+ int ncpus, int ramsize,
+ int net_cap, char *disk_path, int disksize,
+ int mig_netspeed, int dp_intensity)
{
- /* For the moment, intensity_rate is the percentage against the migration bandwidth */
- double host_speed = MSG_get_host_speed(ind_pm);
- double update_speed = ((double)dp_intensity/100) * mig_netspeed;
-
- msg_vm_t vm = MSG_vm_create_core(ind_pm, name);
- s_ws_params_t params;
- memset(¶ms, 0, sizeof(params));
- params.ramsize = 1L * 1024 * 1024 * ramsize;
- //params.overcommit = 0;
- params.devsize = 0;
- params.skip_stage2 = 0;
- params.max_downtime = 0.03;
- params.dp_rate = (update_speed * 1L * 1024 * 1024 ) / host_speed;
- params.dp_cap = params.ramsize / 0.9; // working set memory is 90%
- params.mig_speed = 1L * 1024 * 1024 * mig_netspeed; // mig_speed
-
- //XBT_INFO("dp rate %f migspeed : %f intensity mem : %d, updatespeed %f, hostspeed %f",params.dp_rate, params.mig_speed, dp_intensity, update_speed, host_speed);
- simcall_host_set_params(vm, ¶ms);
-
- return vm;
+ /* For the moment, intensity_rate is the percentage against the migration
+ * bandwidth */
+ double host_speed = MSG_get_host_speed(ind_pm);
+ double update_speed = ((double)dp_intensity/100) * mig_netspeed;
+
+ msg_vm_t vm = MSG_vm_create_core(ind_pm, name);
+ s_ws_params_t params;
+ memset(¶ms, 0, sizeof(params));
+ params.ramsize = (sg_size_t)ramsize * 1024 * 1024;
+ //params.overcommit = 0;
+ params.devsize = 0;
+ params.skip_stage2 = 0;
+ params.max_downtime = 0.03;
+ params.dp_rate = (update_speed * 1024 * 1024) / host_speed;
+ params.dp_cap = params.ramsize * 0.9; // assume working set memory is 90% of ramsize
+ params.mig_speed = (double)mig_netspeed * 1024 * 1024; // mig_speed
+
+ //XBT_INFO("dp rate %f migspeed : %f intensity mem : %d, updatespeed %f, hostspeed %f",params.dp_rate, params.mig_speed, dp_intensity, update_speed, host_speed);
+ simcall_host_set_params(vm, ¶ms);
+
+ return vm;
}
/* We have two mailboxes. mbox is used to transfer migration data between
- * source and destiantion PMs. mbox_ctl is used to detect the completion of a
+ * source and destination PMs. mbox_ctl is used to detect the completion of a
* migration. The names of these mailboxes must not conflict with others. */
static inline char *get_mig_mbox_src_dst(const char *vm_name, const char *src_pm_name, const char *dst_pm_name)
{
double computed = dp->prev_remaining - remaining;
double duration = clock - dp->prev_clock;
- XBT_DEBUG("%s@%s: computated %f ops (remaining %f -> %f) in %f secs (%f -> %f)",
+ 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);
return computed;
dirty_page_t dp = NULL;
xbt_dict_foreach(priv->dp_objs, cursor, key, dp) {
double remaining = MSG_task_get_remaining_computation(dp->task);
-
+
double clock = MSG_get_clock();
// total += calc_updated_pages(key, vm, dp, remaining, clock);
{
msg_host_priv_t priv = msg_host_resource_priv(host);
double remaining = MSG_task_get_remaining_computation(task);
- char *key = bprintf("%s-%lld", task->name, task->counter);
+ char *key = bprintf("%s-%p", task->name, task);
dirty_page_t dp = xbt_new0(s_dirty_page, 1);
dp->task = task;
{
msg_host_priv_t priv = msg_host_resource_priv(host);
- char *key = bprintf("%s-%lld", task->name, task->counter);
+ char *key = bprintf("%s-%p", task->name, task);
dirty_page_t dp = xbt_dict_get_or_null(priv->dp_objs, key);
xbt_assert(dp->task == task);
/* If we are in the middle of dirty page tracking, we record how much
- * computaion has been done until now, and keep the information for the
+ * computation has been done until now, and keep the information for the
* lookup_() function that will called soon. */
if (priv->dp_enabled) {
double remaining = MSG_task_get_remaining_computation(task);
double prio = atof(prio_str);
msg_task_t task = MSG_task_create("__task_deferred", computaion, 0, NULL);
- // XBT_INFO("exec deferred %f", computaion);
+ // XBT_INFO("exec deferred %f", computation);
/* dpt is the results of the VM activity */
MSG_task_set_priority(task, prio);
s_ws_params_t params;
simcall_host_get_params(vm, ¶ms);
const sg_size_t ramsize = params.ramsize;
- const long devsize = params.devsize;
+ const sg_size_t devsize = params.devsize;
const int skip_stage1 = params.skip_stage1;
const int skip_stage2 = params.skip_stage2;
const double dp_rate = params.dp_rate;
double clock_post_send = MSG_get_clock();
double bandwidth = ramsize / (clock_post_send - clock_prev_send);
threshold = get_threshold_value(bandwidth, max_downtime);
- XBT_INFO("actual banwdidth %f (MB/s), threshold %f", bandwidth / 1024 / 1024, threshold);
+ XBT_INFO("actual bandwidth %f (MB/s), threshold %f", bandwidth / 1024 / 1024, threshold);
}
double bandwidth = updated_size / (clock_post_send - clock_prev_send);
threshold = get_threshold_value(bandwidth, max_downtime);
- XBT_INFO("actual banwdidth %f, threshold %f", bandwidth / 1024 / 1024, threshold);
+ XBT_INFO("actual bandwidth %f, threshold %f", bandwidth / 1024 / 1024, threshold);
/** @brief Immediately suspend the execution of all processes within the given VM.
* @ingroup msg_VMs
*
- * This function stops the exection of the VM. All the processes on this VM
- * will pause. The state of the VM is perserved. We can later resume it again.
+ * This function stops the execution of the VM. All the processes on this VM
+ * will pause. The state of the VM is preserved. We can later resume it again.
*
* No suspension cost occurs.
*/
/** @brief Immediately save the execution of all processes within the given VM.
* @ingroup msg_VMs
*
- * This function stops the exection of the VM. All the processes on this VM
- * will pause. The state of the VM is perserved. We can later resume it again.
+ * This function stops the execution of the VM. All the processes on this VM
+ * will pause. The state of the VM is preserved. We can later resume it again.
*
* FIXME: No suspension cost occurs. If you want to simulate this too, you want to
* use a \ref MSG_file_write() before or after, depending on the exact semantic
*
* There are some solutions for this problem. One option is to update the bound
* of the dummy CPU action automatically. It should be the sum of all tasks on
- * the VM. But, this solution might be costy, because we have to scan all tasks
+ * the VM. But, this solution might be costly, because we have to scan all tasks
* on the VM in share_resource() or we have to trap both the start and end of
* task execution.
*
