SimGrid (3.16) UNRELEASED
-
+SimDag
+ - New and Backwards Compatibility break:
+ SD_simulate_with_update (double how_long, xbt_dynar_t changed_tasks_dynar)
+ When one wants to get the list of tasks whose states have changed during a
+ simulation round, s/he has to allocate and free a dynar and use it as argument
+ to this function. The former SD_simulate (double how_long) now returns void.
-- Release target: June 21 2017 -- Da SimGrid team <simgrid-devel@lists.gforge.inria.fr>
SD_task_watch(t3, SD_DONE);
SD_task_watch(c3, SD_DONE);
SD_task_watch(t4, SD_DONE);
-
+ xbt_dynar_t changed_tasks = xbt_dynar_new(sizeof(SD_task_t), NULL);
while (1) {
- xbt_dynar_t changed_tasks = SD_simulate(-1.0);
+ SD_simulate_with_update(-1.0, changed_tasks);
if (xbt_dynar_is_empty(changed_tasks))
break;
XBT_INFO("link1: bw=%.0f, lat=%f", sg_host_route_bandwidth(hosts[0], hosts[1]),
if (SD_task_get_state(task)==SD_DONE)
SD_task_destroy(task);
}
- xbt_dynar_free(&changed_tasks);
+ xbt_dynar_reset(changed_tasks);
}
SD_exit();
xbt_free(hosts);
+ xbt_dynar_free(&changed_tasks);
return 0;
}
xbt_free(hosts);
XBT_INFO("------------------- Run the schedule ---------------------------");
- xbt_dynar_t changed_tasks = SD_simulate(-1);
- xbt_dynar_free(&changed_tasks);
+ SD_simulate(-1);
XBT_INFO("------------------- Produce the trace file---------------------------");
XBT_INFO("Producing the trace of the run into %s", basename(tracefilename));
SD_task_schedulel(task, 1, sg_host_by_name("Faulty Host"));
- xbt_dynar_t tasks = SD_simulate(-1.0);
- xbt_dynar_free(&tasks);
+ SD_simulate(-1.0);
SD_task_dump(task);
SD_task_schedulel(task, 1, sg_host_by_name("Safe Host"));
XBT_INFO("Run the simulation again");
- tasks = SD_simulate(-1.0);
- xbt_dynar_free(&tasks);
+ SD_simulate(-1.0);
SD_task_dump(task);
XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task), SD_task_get_start_time(task),
hosts[0] = sg_host_by_name("Faulty Host");
SD_task_schedule(task, 1, hosts, computation_amount, communication_amount,-1);
- tasks = SD_simulate(-1.0);
- xbt_dynar_free(&tasks);
+ SD_simulate(-1.0);
SD_task_dump(task);
SD_task_schedule(task, 1, hosts, computation_amount, communication_amount,-1);
XBT_INFO("Run the simulation again");
- tasks = SD_simulate(-1.0);
- xbt_dynar_free(&tasks);
+ SD_simulate(-1.0);
SD_task_dump(task);
XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task), SD_task_get_start_time(task),
ws_list = sg_host_list();
reclaimed = xbt_dynar_new(sizeof(bcast_task_t),xbt_free_ref);
- xbt_dynar_t done = NULL;
+ xbt_dynar_t done = xbt_dynar_new(sizeof(SD_task_t), NULL);
xbt_os_cputimer_start(timer);
send_one(0,sg_host_count());
do {
- if (done != NULL && !xbt_dynar_is_empty(done)) {
+ if (!xbt_dynar_is_empty(done)) {
unsigned int cursor;
SD_task_t task;
}
SD_task_destroy(task);
}
- xbt_dynar_free(&done);
+ xbt_dynar_free_container(&done);
}
- done=SD_simulate(-1);
+ SD_simulate_with_update(-1, done);
} while(!xbt_dynar_is_empty(done));
xbt_os_cputimer_stop(timer);
printf("exec_time:%f\n", xbt_os_timer_elapsed(timer) );
xbt_dynar_get_cpy(dax, 0, &task);
sg_host_t host = SD_task_get_best_host(task);
SD_task_schedulel(task, 1, host);
+ xbt_dynar_t changed_tasks = xbt_dynar_new(sizeof(SD_task_t), NULL);
+ SD_simulate_with_update(-1.0, changed_tasks);
- while (!xbt_dynar_is_empty(SD_simulate(-1.0))) {
+ while (!xbt_dynar_is_empty(changed_tasks)) {
/* Get the set of ready tasks */
ready_tasks = get_ready_tasks(dax);
+ xbt_dynar_reset(changed_tasks);
+
if (xbt_dynar_is_empty(ready_tasks)) {
xbt_dynar_free_container(&ready_tasks);
/* there is no ready task, let advance the simulation */
+ SD_simulate_with_update(-1.0, changed_tasks);
continue;
}
/* For each ready task:
xbt_dynar_free_container(&ready_tasks);
/* reset the min_finish_time for the next set of ready tasks */
min_finish_time = -1.;
+ xbt_dynar_reset(changed_tasks);
+ SD_simulate_with_update(-1.0, changed_tasks);
}
XBT_INFO("Simulation Time: %f", SD_get_clock());
free(tracefilename);
xbt_dynar_free_container(&ready_tasks);
+ xbt_dynar_free(&changed_tasks);
xbt_dynar_foreach(dax, cursor, task) {
SD_task_destroy(task);
{
unsigned int ctr;
SD_task_t task;
- xbt_dynar_t changed_tasks;
+ xbt_dynar_t changed_tasks = xbt_dynar_new(sizeof(SD_task_t), NULL);
SD_init(&argc, argv);
xbt_assert(argc > 1, "Usage: %s platform_file\n\nExample: %s two_clusters.xml", argv[0], argv[0]);
SD_task_schedulel(taskA, 1, hosts[0]);
SD_task_schedulel(taskC, 1, hosts[1]);
SD_task_schedulel(taskE, 1, hosts[0]);
- while (!xbt_dynar_is_empty((changed_tasks = SD_simulate(-1.0)))) {
+
+ SD_simulate_with_update(-1.0, changed_tasks);
+ while (!xbt_dynar_is_empty(changed_tasks)) {
XBT_INFO("Simulation stopped after %.4f seconds", SD_get_clock());
xbt_dynar_foreach(changed_tasks, ctr, task) {
XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task), SD_task_get_start_time(task),
SD_task_get_finish_time(task));
}
- xbt_dynar_free(&changed_tasks);
+ xbt_dynar_reset(changed_tasks);
/* let throttle the communication for taskD if its parent is SD_DONE */
/* the bandwidth is 1.25e8, the data size is 1e7, and we want to throttle the bandwidth by a factor 2.
*/
if (SD_task_get_state(taskC) == SD_DONE && SD_task_get_state(taskD) < SD_RUNNING)
SD_task_set_rate(taskD, 6.25);
+ SD_simulate_with_update(-1.0, changed_tasks);
}
+ xbt_dynar_free(&changed_tasks);
+
XBT_DEBUG("Destroying tasks...");
SD_task_destroy(taskA);
SD_task_destroy(taskB);
SD_task_schedule(par_comp3, 4, host_list, computation_amount, communication_amount, -1);
- xbt_dynar_t changed_tasks = SD_simulate(-1.0);
+ xbt_dynar_t changed_tasks = xbt_dynar_new(sizeof(SD_task_t), NULL);
+ SD_simulate_with_update(-1.0, changed_tasks);
xbt_dynar_foreach(changed_tasks, ctr, task) {
XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task), SD_task_get_start_time(task),
SD_task_get_finish_time(task));
XBT_PUBLIC(void) SD_init(int *argc, char **argv);
XBT_PUBLIC(void) SD_config(const char *key, const char *value);
XBT_PUBLIC(void) SD_create_environment(const char *platform_file);
-XBT_PUBLIC(xbt_dynar_t) SD_simulate(double how_long);
+XBT_PUBLIC(void) SD_simulate(double how_long);
+XBT_PUBLIC(void) SD_simulate_with_update(double how_long, xbt_dynar_t changed_tasks_dynar);
XBT_PUBLIC(double) SD_get_clock();
XBT_PUBLIC(void) SD_exit();
XBT_PUBLIC(xbt_dynar_t) SD_daxload(const char *filename);
* \return a dynar of \ref SD_task_t whose state has changed.
* \see SD_task_schedule(), SD_task_watch()
*/
+void SD_simulate(double how_long)
+{
+ simgrid::sd::simulate(how_long);
+}
-xbt_dynar_t SD_simulate(double how_long) {
+void SD_simulate_with_update(double how_long, xbt_dynar_t changed_tasks_dynar)
+{
std::set<SD_task_t> *changed_tasks = simgrid::sd::simulate(how_long);
- xbt_dynar_t changed_tasks_dynar = xbt_dynar_new(sizeof(SD_task_t), nullptr);
for (const auto& task : *changed_tasks)
xbt_dynar_push(changed_tasks_dynar, &task);
- return changed_tasks_dynar;
}
/** @brief Returns the current clock, in seconds */
XBT_INFO("Scheduling DAX...");
scheduleDAX(dax);
XBT_INFO("DAX scheduled");
- xbt_dynar_t changed_tasks = SD_simulate(-1);
- xbt_dynar_free(&changed_tasks);
+ SD_simulate(-1);
XBT_INFO("Simulation done.");
{
double comm_cost[] = { 0.0, 0.0, 0.0, 0.0 };
double comp_cost[] = { 1.0 };
- xbt_dynar_t ret;
+ xbt_dynar_t ret = xbt_dynar_new(sizeof(SD_task_t), NULL);
SD_init(&argc, argv);
SD_create_environment(argv[1]);
SD_task_schedule(taskB, 1, hosts, comp_cost, comm_cost, -1.0);
xbt_free(hosts);
- ret = SD_simulate(-1.0);
+ SD_simulate_with_update(-1.0, ret);
xbt_assert(xbt_dynar_length(ret) == 2, "I was expecting the completion of 2 tasks, but I got %lu instead",
xbt_dynar_length(ret));
SD_task_destroy(taskA);