Comment unused function parameters.

[simgrid.git] / src / simdag / sd_task.cpp

diff --git a/src/simdag/sd_task.cpp b/src/simdag/sd_task.cpp
index b75326d..2894ffa 100644 (file)
--- a/src/simdag/sd_task.cpp
+++ b/src/simdag/sd_task.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2006-2017. The SimGrid Team.
+/* Copyright (c) 2006-2018. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -287,9 +287,9 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
 
   if (new_state == SD_DONE || new_state == SD_FAILED){
     sd_global->completed_tasks->insert(task);
-    task->start_time = task->surf_action->getStartTime();
+    task->start_time = task->surf_action->get_start_time();
     if (new_state == SD_DONE){
-      task->finish_time = task->surf_action->getFinishTime();
+      task->finish_time = task->surf_action->get_finish_time();
 #if SIMGRID_HAVE_JEDULE
       jedule_log_sd_event(task);
 #endif
@@ -435,7 +435,7 @@ double SD_task_get_alpha(SD_task_t task)
 double SD_task_get_remaining_amount(SD_task_t task)
 {
   if (task->surf_action)
-    return task->surf_action->getRemains();
+    return task->surf_action->get_remains();
   else
     return (task->state == SD_DONE) ? 0 : task->amount;
 }
@@ -527,13 +527,11 @@ void SD_task_dotty(SD_task_t task, void *out)
  * \a dst will depend on \a src, ie \a dst will not start before \a src is finished.
  * Their \ref e_SD_task_state_t "state" must be #SD_NOT_SCHEDULED, #SD_SCHEDULED or #SD_RUNNABLE.
  *
- * \param name the name of the new dependency (can be \c nullptr)
- * \param data the user data you want to associate with this dependency (can be \c nullptr)
  * \param src the task which must be executed first
  * \param dst the task you want to make depend on \a src
  * \see SD_task_dependency_remove()
  */
-void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst)
+void SD_task_dependency_add(SD_task_t src, SD_task_t dst)
 {
   if (src == dst)
     THROWF(arg_error, 0, "Cannot add a dependency between task '%s' and itself", SD_task_get_name(src));
@@ -669,15 +667,14 @@ void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state)
  * The estimation is very approximative because the value returned is the time the task would take if it was executed
  * now and if it was the only task.
  *
- * \param task the task to evaluate
  * \param host_count number of hosts on which the task would be executed
  * \param host_list the hosts on which the task would be executed
  * \param flops_amount computation amount for each host(i.e., an array of host_count doubles)
  * \param bytes_amount communication amount between each pair of hosts (i.e., a matrix of host_count*host_count doubles)
  * \see SD_schedule()
  */
-double SD_task_get_execution_time(SD_task_t task, int host_count, const sg_host_t *host_list,
-                                  const double *flops_amount, const double *bytes_amount)
+double SD_task_get_execution_time(SD_task_t /*task*/, int host_count, const sg_host_t* host_list,
+                                  const double* flops_amount, const double* bytes_amount)
 {
   xbt_assert(host_count > 0, "Invalid parameter");
   double max_time = 0.0;
@@ -686,7 +683,7 @@ double SD_task_get_execution_time(SD_task_t task, int host_count, const sg_host_
   for (int i = 0; i < host_count; i++) {
     double time = 0.0;
     if (flops_amount != nullptr)
-      time = flops_amount[i] / host_list[i]->getSpeed();
+      time = flops_amount[i] / host_list[i]->get_speed();
 
     if (bytes_amount != nullptr)
       for (int j = 0; j < host_count; j++)
@@ -810,9 +807,9 @@ void SD_task_run(SD_task_t task)
   if(task->bytes_amount)
     std::copy_n(task->bytes_amount, host_nb * host_nb, bytes_amount);
 
-  task->surf_action = surf_host_model->executeParallelTask(host_nb, hosts, flops_amount, bytes_amount, task->rate);
+  task->surf_action = surf_host_model->execute_parallel(host_nb, hosts, flops_amount, bytes_amount, task->rate);
 
-  task->surf_action->setData(task);
+  task->surf_action->set_data(task);
 
   XBT_DEBUG("surf_action = %p", task->surf_action);
 
@@ -832,7 +829,7 @@ void SD_task_run(SD_task_t task)
 double SD_task_get_start_time(SD_task_t task)
 {
   if (task->surf_action)
-    return task->surf_action->getStartTime();
+    return task->surf_action->get_start_time();
   else
     return task->start_time;
 }
@@ -850,7 +847,7 @@ double SD_task_get_start_time(SD_task_t task)
 double SD_task_get_finish_time(SD_task_t task)
 {
   if (task->surf_action)        /* should never happen as actions are destroyed right after their completion */
-    return task->surf_action->getFinishTime();
+    return task->surf_action->get_finish_time();
   else
     return task->finish_time;
 }
@@ -882,7 +879,8 @@ void SD_task_build_MxN_1D_block_matrix(SD_task_t task, int src_nb, int dst_nb){
       XBT_VERB("(%d->%d): (%.2f, %.2f)-> (%.2f, %.2f)", i, j, src_start, src_end, dst_start, dst_end);
       task->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
       if ((src_end > dst_start) && (dst_end > src_start)) { /* There is something to send */
-        task->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] = MIN(src_end, dst_end)- MAX(src_start, dst_start);
+        task->bytes_amount[i * (src_nb + dst_nb) + src_nb + j] =
+            std::min(src_end, dst_end) - std::max(src_start, dst_start);
         XBT_VERB("==> %.2f", task->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]);
       }
     }
@@ -970,12 +968,12 @@ void SD_task_schedulev(SD_task_t task, int count, const sg_host_t * list)
 void SD_task_schedulel(SD_task_t task, int count, ...)
 {
   va_list ap;
-  sg_host_t *list = xbt_new(sg_host_t, count);
+  sg_host_t* list = new sg_host_t[count];
   va_start(ap, count);
   for (int i=0; i<count; i++)
     list[i] = va_arg(ap, sg_host_t);
 
   va_end(ap);
   SD_task_schedulev(task, count, list);
-  xbt_free(list);
+  delete[] list;
 }