-/* Copyright (c) 2004-2015. The SimGrid Team.
- * All rights reserved. */
+/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
-#include "msg_private.h"
-#include "src/simix/smx_private.h"
-#include "xbt/sysdep.h"
-#include "xbt/log.h"
+#include "msg_private.hpp"
+#include "src/simix/smx_private.hpp"
+#include <algorithm>
+
+extern "C" {
/** @addtogroup m_task_management
*
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_task, msg, "Logging specific to MSG (task)");
-void simdata_task::reportMultipleUse() const
+void s_simdata_task_t::reportMultipleUse() const
{
if (msg_global->debug_multiple_use){
XBT_ERROR("This task is already used in there:");
*/
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;
task->data = data;
/* Simulator Data */
- simdata->compute = nullptr;
- simdata->comm = nullptr;
simdata->bytes_amount = message_size;
simdata->flops_amount = flop_amount;
- simdata->sender = nullptr;
- simdata->receiver = nullptr;
- simdata->source = nullptr;
- simdata->priority = 1.0;
- simdata->bound = 0;
- simdata->rate = -1.0;
- simdata->isused = 0;
-
- simdata->host_nb = 0;
- simdata->host_list = nullptr;
- simdata->flops_parallel_amount = nullptr;
- simdata->bytes_parallel_amount = nullptr;
+
TRACE_msg_task_create(task);
return task;
{
msg_task_t task = MSG_task_create(name, 0, 0, data);
simdata_task_t simdata = task->simdata;
- int i;
/* Simulator Data specific to parallel tasks */
simdata->host_nb = host_nb;
- simdata->host_list = xbt_new0(sg_host_t, host_nb);
- simdata->flops_parallel_amount = flops_amount;
- simdata->bytes_parallel_amount = bytes_amount;
-
- for (i = 0; i < host_nb; i++)
- simdata->host_list[i] = host_list[i];
+ simdata->host_list = new sg_host_t[host_nb];
+ std::copy_n(host_list, host_nb, simdata->host_list);
+ if (flops_amount != nullptr) {
+ simdata->flops_parallel_amount = new double[host_nb];
+ std::copy_n(flops_amount, host_nb, simdata->flops_parallel_amount);
+ }
+ if (bytes_amount != nullptr) {
+ simdata->bytes_parallel_amount = new double[host_nb * host_nb];
+ std::copy_n(bytes_amount, host_nb * host_nb, simdata->bytes_parallel_amount);
+ }
return task;
}
*/
void *MSG_task_get_data(msg_task_t task)
{
- xbt_assert((task != nullptr), "Invalid parameter");
return (task->data);
}
*/
void MSG_task_set_data(msg_task_t task, void *data)
{
- xbt_assert((task != nullptr), "Invalid parameter");
task->data = data;
}
*/
msg_process_t MSG_task_get_sender(msg_task_t task)
{
- xbt_assert(task, "Invalid parameters");
- return (static_cast<simdata_task_t> (task->simdata)->sender);
+ return task->simdata->sender;
}
/** \ingroup m_task_management
*/
msg_host_t MSG_task_get_source(msg_task_t task)
{
- xbt_assert(task, "Invalid parameters");
- return (static_cast<simdata_task_t> (task->simdata)->source);
+ return task->simdata->source;
}
/** \ingroup m_task_management
*/
const char *MSG_task_get_name(msg_task_t task)
{
- xbt_assert(task, "Invalid parameters");
return task->name;
}
*/
void MSG_task_set_name(msg_task_t task, const char *name)
{
- xbt_assert(task, "Invalid parameters");
task->name = xbt_strdup(name);
}
*/
msg_error_t MSG_task_destroy(msg_task_t task)
{
- xbt_assert((task != nullptr), "Invalid parameter");
-
if (task->simdata->isused) {
/* the task is being sent or executed: cancel it first */
MSG_task_cancel(task);
/* 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);
+ MSG_host_del_task(MSG_process_get_host(MSG_process_self()), task);
+ } 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.
+ * TODO: Improve this function by returning 1 if the task has not started
*/
-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 or finished
+ return 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;
}
}
*/
double MSG_task_get_remaining_communication(msg_task_t task)
{
- XBT_DEBUG("calling simcall_communication_get_remains(%p)", task->simdata->comm);
+ XBT_DEBUG("calling simcall_communication_get_remains(%p)", task->simdata->comm.get());
return task->simdata->comm->remains();
}
*/
void MSG_task_set_priority(msg_task_t task, double priority)
{
- xbt_assert((task != nullptr) && (task->simdata != nullptr), "Invalid parameter");
task->simdata->priority = 1 / priority;
if (task->simdata->compute)
- simcall_execution_set_priority(task->simdata->compute,
- task->simdata->priority);
+ simcall_execution_set_priority(task->simdata->compute, task->simdata->priority);
}
/** \ingroup m_task_management
*/
void MSG_task_set_bound(msg_task_t task, double bound)
{
- xbt_assert(task, "Invalid parameter");
- xbt_assert(task->simdata, "Invalid parameter");
-
if (bound < 1e-12) /* close enough to 0 without any floating precision surprise */
XBT_INFO("bound == 0 means no capping (i.e., unlimited).");
if (task->simdata->compute)
simcall_execution_set_bound(task->simdata->compute, task->simdata->bound);
}
+}