* mandatory power.
*
* A parallel computation can be scheduled on any number of host.
- * The underlying speedup model is Amdahl's law.
- * To be auto-scheduled, \see SD_task_distribute_comp_amdhal has to be called
+ * The underlying speedup model is Amdahl's law.
+ * To be auto-scheduled, \see SD_task_distribute_comp_amdahl has to be called
* first.
* \param name the name of the task (can be \c NULL)
* \param data the user data you want to associate with the task (can be \c NULL)
}
/**
- * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAH task
+ * \brief Sets the total amount of work of a task
+ * For sequential typed tasks (COMP_SEQ and COMM_E2E), it also sets the
+ * appropriate values in the computation_amount and communication_amount arrays
+ * respectively. Nothing more than modifying task->amount is done for paralle
+ * typed tasks (COMP_PAR_AMDAHL and COMM_PAR_MXN_1D_BLOCK) as the distribution
+ * of the amount of work is done at scheduling time.
+ *
+ * \param task a task
+ * \param amount the new amount of work to execute
+ */
+void SD_task_set_amount(SD_task_t task, double amount)
+{
+ task->amount = amount;
+ if (task->kind == SD_TASK_COMP_SEQ)
+ task->computation_amount[0] = amount;
+ if (task->kind == SD_TASK_COMM_E2E)
+ task->communication_amount[2] = amount;
+}
+
+/**
+ * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAHL task
*
* \param task a parallel task assuming Amdahl's law as speedup model
* \return the alpha parameter (serial part of a task in percent) for this task
&& ((task->kind == SD_TASK_COMP_PAR_AMDAHL) ||
(task->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK))) { /* Don't free scheduling data for typed tasks */
__SD_task_destroy_scheduling_data(task);
+ xbt_free(task->workstation_list);
task->workstation_list=NULL;
task->workstation_nb = 0;
}
/** @brief Blah
*
*/
-void SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count)
+void SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count)
{
int i;
xbt_assert(task->kind == SD_TASK_COMP_PAR_AMDAHL,
SD_task_get_name(task));
task->computation_amount = xbt_new0(double, ws_count);
task->communication_amount = xbt_new0(double, ws_count * ws_count);
- if (task->workstation_list)
- xbt_free(task->workstation_list);
+ xbt_free(task->workstation_list);
task->workstation_nb = ws_count;
task->workstation_list = xbt_new0(SD_workstation_t, ws_count);
SD_task_get_name(task));
switch (task->kind) {
case SD_TASK_COMP_PAR_AMDAHL:
- SD_task_distribute_comp_amdhal(task, count);
+ SD_task_distribute_comp_amdahl(task, count);
case SD_TASK_COMM_E2E:
case SD_TASK_COMP_SEQ:
xbt_assert(task->workstation_nb == count,
* located (and start them if runnable) */
if (task->kind == SD_TASK_COMP_PAR_AMDAHL) {
XBT_VERB("Schedule computation task %s on %d workstations. %.f flops"
- " will be distributed following Amdahl'Law",
+ " will be distributed following Amdahl's Law",
SD_task_get_name(task), task->workstation_nb,
task->computation_amount[0]);
xbt_dynar_foreach(task->tasks_before, cpt, dep) {
task->workstation_list[i];
before->workstation_nb += count;
- if (before->computation_amount)
- xbt_free(before->computation_amount);
- if (before->communication_amount)
- xbt_free(before->communication_amount);
-
+ xbt_free(before->computation_amount);
+ xbt_free(before->communication_amount);
before->computation_amount = xbt_new0(double,
before->workstation_nb);
before->communication_amount = xbt_new0(double,
after->workstation_nb += count;
- if (after->computation_amount)
- xbt_free(after->computation_amount);
- if (after->communication_amount)
- xbt_free(after->communication_amount);
+ xbt_free(after->computation_amount);
+ xbt_free(after->communication_amount);
after->computation_amount = xbt_new0(double, after->workstation_nb);
after->communication_amount = xbt_new0(double,