if (SD_task_get_state(task)==SD_DONE)
SD_task_destroy(task);
}
+ xbt_dynar_free_container(&changed_tasks);
}
+ xbt_dynar_free_container(&changed_tasks);
SD_exit();
return 0;
}
*/
if (SD_task_get_state(taskC) == SD_DONE)
SD_task_set_rate(taskD, 6.25);
+ xbt_dynar_free_container(&changed_tasks);
}
+ xbt_dynar_free_container(&changed_tasks);
XBT_DEBUG("Destroying tasks...");
double computation_amount[1];
double communication_amount[2] = { 0 };
SD_workstation_t workstation_list[1];
+ xbt_dynar_t ret;
+
/* initialization of SD */
SD_init(&argc, argv);
SD_task_schedulel(task, 1, SD_workstation_get_by_name("Faulty Host"));
- SD_simulate(-1.0);
+ ret = SD_simulate(-1.0);
+ xbt_dynar_free(&ret);
SD_task_dump(task);
SD_task_schedulel(task, 1, SD_workstation_get_by_name("Safe Host"));
XBT_INFO("Run the simulation again");
- SD_simulate(-1.0);
+ ret = SD_simulate(-1.0);
+ xbt_dynar_free(&ret);
SD_task_dump(task);
XBT_INFO("Task '%s' start time: %f, finish time: %f",
SD_task_schedule(task, 1, workstation_list,
computation_amount, communication_amount,-1);
- SD_simulate(-1.0);
+ ret = SD_simulate(-1.0);
+ xbt_dynar_free(&ret);
SD_task_dump(task);
computation_amount, communication_amount,-1);
XBT_INFO("Run the simulation again");
- SD_simulate(-1.0);
+ ret = SD_simulate(-1.0);
+ xbt_dynar_free(&ret);
SD_task_dump(task);
XBT_INFO("Task '%s' start time: %f, finish time: %f",
while (!xbt_dynar_is_empty(changed_tasks = SD_simulate(-1.0))) {
XBT_INFO(" Simulation was suspended, check workstation states");
for (i = 0; i < 2; i++) {
- SD_workstation_dump(workstations[i]);
+ SD_workstation_dump(workstations[i]);
}
xbt_dynar_free(&changed_tasks);
}
SD_task_destroy(taskA);
SD_task_destroy(taskB);
SD_task_destroy(taskC);
+ SD_task_destroy(taskD);
XBT_DEBUG("Tasks destroyed. Exiting SimDag...");
SD_task_get_start_time(task), SD_task_get_finish_time(task));
SD_task_destroy(task);
}
-
+ xbt_dynar_free_container(&changed_tasks);
SD_exit();
return 0;
}
}
xbt_dynar_free_container(&changed_tasks);
}
+ xbt_dynar_free_container(&changed_tasks);
XBT_DEBUG("Destroying tasks...");
void jedule_sd_cleanup(void);
+void jedule_sd_exit(void);
+
void jedule_sd_dump(void);
#endif /* JEDULE_SD_BINDING_H_ */
(*event)->type = xbt_strdup(type);
- (*event)->resource_subsets = xbt_dynar_new(sizeof(jed_res_subset_t), NULL);
+ (*event)->resource_subsets = xbt_dynar_new(sizeof(jed_res_subset_t), xbt_free_ref);
(*event)->characteristics_list = xbt_dynar_new(sizeof(char*), NULL);
(*event)->info_hash = xbt_dict_new_homogeneous(NULL);
int start = subset->start_idx;
int end = subset->start_idx + subset->nres - 1;
- char resid[1024];
+ char resid[1024];
- get_hierarchy_string(subset->parent, resid);
+ get_hierarchy_string(subset->parent, resid);
fprintf(jed_file, "<select resources=\"");
- fprintf(jed_file, "%s", resid);
+ fprintf(jed_file, "%s", resid);
fprintf(jed_file, ".[%d-%d]", start, end);
fprintf(jed_file, "\" />\n");
}
}
+static void jed_event_free_ref(void *evp)
+{
+ jed_event_t ev = *(jed_event_t *)evp;
+ jed_event_free(ev);
+}
+
void jedule_init_output() {
- jedule_event_list = xbt_dynar_new(sizeof(jed_event_t), NULL);
+ jedule_event_list = xbt_dynar_new(sizeof(jed_event_t), jed_event_free_ref);
}
void jedule_cleanup_output() {
xbt_dynar_foreach(container->container_children, iter, child_container) {
jed_free_container(child_container);
}
+ xbt_dynar_free(&container->container_children);
}
- free(container->name);
- free(container);
+ xbt_free(container->name);
+ xbt_free(container);
}
void jed_simgrid_create_container(jed_simgrid_container_t *container, char *name) {
// printf("subset parent >>> %s\n", parent->name);
add_subsets_to(subset_list, hostgroup, parent);
}
-
+ xbt_dynar_free(&hostgroup);
}
xbt_dict_free(&parent2hostgroup);
jed_free_container(jedule->root_container);
xbt_dict_free(&jedule->jedule_meta_info);
- free(jedule);
+ xbt_free(jedule);
xbt_dict_free(&host2_simgrid_parent_container);
xbt_dict_free(&container_name2container);
xbt_dynar_foreach(current_comp->index_network_elm,
dynar_cursor, network_elem) {
- char *hostname;
- hostname = strdup(network_elem->name);
- xbt_dynar_push(hosts, &hostname);
+ xbt_dynar_push_as(hosts, char*, network_elem->name);
}
jed_simgrid_add_resources(current_container, hosts);
-
+ xbt_dynar_free(&hosts);
} else {
xbt_dict_foreach(current_comp->routing_sons, cursor, key, elem) {
jed_simgrid_container_t child_container;
jedule_init_output();
}
+void jedule_sd_exit(void)
+{
+ jed_free_jedule(jedule);
+ jedule = NULL;
+}
+
void jedule_sd_dump() {
FILE *fh;
char fname[1024];
}
//set task category
- if (task->category)
- xbt_free(task->category);
+ xbt_free(task->category);
task->category = xbt_strdup (category);
XBT_DEBUG("SD task %p(%s), category %s", task, task->name, task->category);
}
TRACE_end();
#endif
- XBT_DEBUG("Exiting Surf...");
- surf_exit();
-
xbt_free(sd_global);
sd_global = NULL;
#ifdef HAVE_JEDULE
jedule_sd_dump();
jedule_sd_cleanup();
+ jedule_sd_exit();
#endif
+
+ XBT_DEBUG("Exiting Surf...");
+ surf_exit();
}
&& ((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;
}
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);
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,
free(((surf_action_workstation_L07_t) action)->workstation_list);
free(((surf_action_workstation_L07_t) action)->communication_amount);
free(((surf_action_workstation_L07_t) action)->computation_amount);
+#ifdef HAVE_TRACING
+ xbt_free(action->category);
+#endif
surf_action_free(&action);
return 1;
}
fprintf(stdout, "Scheduling DAX...\n");
scheduleDAX(dax);
fprintf(stdout, "DAX scheduled\n");
- SD_simulate(-1);
+ xbt_dynar_t ret = SD_simulate(-1);
+ xbt_dynar_free(&ret);
fprintf(stdout, "Simulation end. Time: %f\n", SD_get_clock());
return dax;
*/
static void garbageCollector(xbt_dynar_t dax)
{
- SD_task_t task;
- unsigned int cursor;
- xbt_dynar_foreach(dax, cursor, task) {
+ while (!xbt_dynar_is_empty(dax)) {
+ SD_task_t task = xbt_dynar_pop_as(dax, SD_task_t);
SD_task_destroy(task);
}
+ xbt_dynar_free(&dax);
SD_exit();
}
printf("</platform>\n");
}
SD_exit();
+ xbt_os_timer_free(parse_time);
return 0;
}