*/
msg_task_t MSG_task_create(const char *name, double flop_amount, double message_size, void *data)
{
- msg_task_t task = xbt_new(s_msg_task_t, 1);
+ msg_task_t task = new s_msg_task_t;
simdata_task_t simdata = new s_simdata_task_t();
task->simdata = simdata;
msg_task_t MSG_parallel_task_create(const char *name, int host_nb, const msg_host_t * host_list,
double *flops_amount, double *bytes_amount, void *data)
{
- msg_task_t task = MSG_task_create(name, 0, 0, data);
+ // Task's flops amount is set to an arbitrary value > 0.0 to be able to distinguish, in
+ // MSG_task_get_remaining_work_ratio(), a finished task and a task that has not started yet.
+ msg_task_t task = MSG_task_create(name, 1.0, 0, data);
simdata_task_t simdata = task->simdata;
/* Simulator Data specific to parallel tasks */
/* free main structures */
delete task->simdata;
- xbt_free(task);
+ delete task;
return MSG_OK;
}
{
xbt_assert((task != nullptr), "Cannot cancel a nullptr task");
- if (task->simdata->compute) {
- simcall_execution_cancel(task->simdata->compute);
- }
- else if (task->simdata->comm) {
- simdata_task_t simdata = task->simdata;
+ simdata_task_t simdata = task->simdata;
+ if (simdata->compute) {
+ simcall_execution_cancel(simdata->compute);
+ } else if (simdata->comm) {
simcall_comm_cancel(simdata->comm);
- simdata->setNotUsed();
}
+ simdata->setNotUsed();
return MSG_OK;
}
/** \ingroup m_task_management
- * \brief Returns the remaining amount of flops needed to execute a task #msg_task_t.
+ * \brief Returns a value in ]0,1[ that represent the task remaining work
+ * to do: starts at 1 and goes to 0. Returns 0 if not started or finished.
*
- * Once a task has been processed, this amount is set to 0. If you want, you can reset this value with
- * #MSG_task_set_flops_amount before restarting the task.
+ * It works for either parallel or sequential tasks.
*/
-double MSG_task_get_flops_amount(msg_task_t task) {
+double MSG_task_get_remaining_work_ratio(msg_task_t task) {
+
+ xbt_assert((task != nullptr), "Cannot get information from a nullptr task");
if (task->simdata->compute) {
+ // Task in progress
+ return task->simdata->compute->remainingRatio();
+ } else {
+ // Task not started (flops_amount is > 0.0) or finished (flops_amount is set to 0.0)
+ return task->simdata->flops_amount > 0.0 ? 1.0 : 0.0;
+ }
+}
+
+/** \ingroup m_task_management
+ * \brief Returns the amount of flops that remain to be computed
+ *
+ * The returned value is initially the cost that you defined for the task, then it decreases until it reaches 0
+ *
+ * It works for sequential tasks, but the remaining amount of work is not a scalar value for parallel tasks.
+ * So you will get an exception if you call this function on parallel tasks. Just don't do it.
+ */
+double MSG_task_get_flops_amount(msg_task_t task) {
+ if (task->simdata->compute != nullptr) {
return task->simdata->compute->remains();
} else {
+ // Not started or already done.
+ // - Before starting, flops_amount is initially the task cost
+ // - After execution, flops_amount is set to 0 (until someone uses MSG_task_set_flops_amount, if any)
return task->simdata->flops_amount;
}
}