int main(int argc, char **argv)
{
unsigned int ctr;
SD_task_t task;
xbt_dynar_t changed_tasks;
SD_init(&argc, argv);
SD_create_environment(argv[1]);
const sg_host_t *hosts = sg_host_list();
SD_task_t t1 = SD_task_create_comp_seq("t1", NULL, 25000000);
SD_task_t c1 = SD_task_create_comm_e2e("c1", NULL, 125000000);
SD_task_t t2 = SD_task_create_comp_seq("t2", NULL, 25000000);
SD_task_t c2 = SD_task_create_comm_e2e("c2", NULL, 62500000);
SD_task_t t3 = SD_task_create_comp_seq("t3", NULL, 25000000);
SD_task_t c3 = SD_task_create_comm_e2e("c3", NULL, 31250000);
SD_task_t t4 = SD_task_create_comp_seq("t4", NULL, 25000000);
/* Add dependencies: t1->c1->t2->c2->t3 */
SD_task_dependency_add(NULL, NULL, t1, c1);
SD_task_dependency_add(NULL, NULL, c1, t2);
SD_task_dependency_add(NULL, NULL, t2, c2);
SD_task_dependency_add(NULL, NULL, c2, t3);
SD_task_dependency_add(NULL, NULL, t3, c3);
SD_task_dependency_add(NULL, NULL, c3, t4);
/* Schedule tasks t1 and w3 on first host, t2 on second host */
/* Transfers are auto-scheduled */
SD_task_schedulel(t1, 1, hosts[0]);
SD_task_schedulel(t2, 1, hosts[1]);
SD_task_schedulel(t3, 1, hosts[0]);
SD_task_schedulel(t4, 1, hosts[1]);
/* Add some watchpoint upon task completion */
SD_task_watch(t1, SD_DONE);
SD_task_watch(c1, SD_DONE);
SD_task_watch(t2, SD_DONE);
SD_task_watch(c2, SD_DONE);
SD_task_watch(t3, SD_DONE);
SD_task_watch(c3, SD_DONE);
SD_task_watch(t4, SD_DONE);
while (!xbt_dynar_is_empty((changed_tasks = SD_simulate(-1.0)))) {
XBT_INFO("link1: bw=%.0f, lat=%f", SD_route_get_bandwidth(hosts[0], hosts[1]),
SD_route_get_latency(hosts[0], hosts[1]));
XBT_INFO("Jupiter: speed=%.0f", sg_host_speed(hosts[0])* sg_host_get_available_speed(hosts[0]));
XBT_INFO("Tremblay: speed=%.0f", sg_host_speed(hosts[1])* sg_host_get_available_speed(hosts[1]));
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));
if (SD_task_get_state(task)==SD_DONE)
SD_task_destroy(task);
}
}
int main(int argc, char **argv)
{
char *platformFile = NULL;
unsigned int totalHosts, totalLinks;
int timings=0;
int version = 4;
const char *link_ctn = "link_ctn";
unsigned int i;
xbt_dict_t props = NULL;
xbt_dict_cursor_t cursor = NULL;
xbt_lib_cursor_t cursor_src = NULL;
xbt_lib_cursor_t cursor_dst = NULL;
char *src,*dst,*key,*data;
sg_netcard_t value1;
sg_netcard_t value2;
const sg_host_t *hosts;
const SD_link_t *links;
xbt_os_timer_t parse_time = xbt_os_timer_new();
SD_init(&argc, argv);
if (parse_cmdline(&timings, &platformFile, argc, argv) || !platformFile) {
xbt_die("Invalid command line arguments: expected [--timings] platformFile");
}
XBT_DEBUG("%d,%s", timings, platformFile);
create_environment(parse_time, platformFile);
if (timings) {
XBT_INFO("Parsing time: %fs (%zu hosts, %d links)", xbt_os_timer_elapsed(parse_time),
sg_host_count(), sg_link_count());
} else {
printf("<?xml version='1.0'?>\n");
printf("<!DOCTYPE platform SYSTEM \"http://simgrid.gforge.inria.fr/simgrid/simgrid.dtd\">\n");
printf("<platform version=\"%d\">\n", version);
printf("<AS id=\"AS0\" routing=\"Full\">\n");
// Hosts
totalHosts = sg_host_count();
hosts = sg_host_list();
qsort((void *) hosts, totalHosts, sizeof(sg_host_t), name_compare_hosts);
for (i = 0; i < totalHosts; i++) {
printf(" <host id=\"%s\" speed=\"%.0f\"", sg_host_get_name(hosts[i]), sg_host_speed(hosts[i]));
props = sg_host_get_properties(hosts[i]);
if (sg_host_core_count(hosts[i])>1) {
printf(" core=\"%d\"", sg_host_core_count(hosts[i]));
}
if (props && !xbt_dict_is_empty(props)) {
printf(">\n");
xbt_dict_foreach(props, cursor, key, data) {
printf(" <prop id=\"%s\" value=\"%s\"/>\n", key, data);
}
printf(" </host>\n");
} else {
/* Activate a resource, i.e., act as if a VM is started on a host. This amounts to :
* - setting attributes to 'ON' and 'idle'
* - Resetting the start time of the host to the current time
* - bill at least the first hour
* If a provisioning delay is needed before a VM is actually available for executing task, this function :
* - creates a task whose name is "Booting " followed by the host name
* - schedules this task on the host
* - Ensures that no compute task can be executed before the completion of this booting task.
*/
void sg_host_start(sg_host_t host){
HostAttribute attr = (HostAttribute) sg_host_user(host);
char name[1024];
attr->on_off = 1;
attr->idle_busy = 0;
attr->start_time = SD_get_clock();
attr->total_cost += attr->price;
if (attr->provisioning_delay){
sprintf(name,"Booting %s", sg_host_get_name(host));
attr->booting = SD_task_create_comp_seq(name, NULL, attr->provisioning_delay*sg_host_speed(host));
SD_task_schedulel(attr->booting, 1, host);
attr->available_at += attr->provisioning_delay;
handle_resource_dependency(host, attr->booting);
}
XBT_DEBUG("VM started on %s: Total cost is now $%f for this host", sg_host_get_name(host), attr->total_cost);
sg_host_user_set(host, attr);
}
static double finish_on_at(SD_task_t task, sg_host_t host)
{
double result;
unsigned int i;
double data_available = 0.;
double redist_time = 0;
double last_data_available;
xbt_dynar_t parents = SD_task_get_parents(task);
if (!xbt_dynar_is_empty(parents)) {
/* compute last_data_available */
SD_task_t parent;
last_data_available = -1.0;
xbt_dynar_foreach(parents, i, parent) {
/* normal case */
if (SD_task_get_kind(parent) == SD_TASK_COMM_E2E) {
xbt_dynar_t grand_parents = SD_task_get_parents(parent);
SD_task_t grand_parent;
xbt_assert(xbt_dynar_length(grand_parents) <2, "Error: transfer %s has 2 parents", SD_task_get_name(parent));
xbt_dynar_get_cpy(grand_parents, 0, &grand_parent);
sg_host_t * grand_parent_host_list = SD_task_get_workstation_list(grand_parent);
/* Estimate the redistribution time from this parent */
if (SD_task_get_amount(parent) <= 1e-6){
redist_time= 0;
} else {
redist_time = SD_route_get_latency(grand_parent_host_list[0], host) +
SD_task_get_amount(parent) / SD_route_get_bandwidth(grand_parent_host_list[0], host);
}
data_available = SD_task_get_finish_time(grand_parent) + redist_time;
xbt_dynar_free_container(&grand_parents);
}
/* no transfer, control dependency */
if (SD_task_get_kind(parent) == SD_TASK_COMP_SEQ) {
data_available = SD_task_get_finish_time(parent);
}
if (last_data_available < data_available)
last_data_available = data_available;
}
xbt_dynar_free_container(&parents);
result = MAX(sg_host_get_available_at(host), last_data_available) + SD_task_get_amount(task)/sg_host_speed(host);
} else {
int main(int argc, char **argv)
{
sg_host_t host_list[2];
double computation_amount[2];
double communication_amount[4] = { 0 };
/* initialization of SD */
SD_init(&argc, argv);
xbt_assert(argc > 1, "Usage: %s platform_file\n\nExample: %s two_clusters.xml", argv[0], argv[0]);
SD_create_environment(argv[1]);
/* test the estimation functions */
const sg_host_t *hosts = sg_host_list();
sg_host_t h1 = hosts[0];
sg_host_t h2 = hosts[1];
const char *name1 = sg_host_get_name(h1);
const char *name2 = sg_host_get_name(h2);
double comp_amount1 = 2000000;
double comp_amount2 = 1000000;
double comm_amount12 = 2000000;
double comm_amount21 = 3000000;
XBT_INFO("Computation time for %f flops on %s: %f", comp_amount1, name1, comp_amount1/sg_host_speed(h1));
XBT_INFO("Computation time for %f flops on %s: %f", comp_amount2, name2, comp_amount2/sg_host_speed(h2));
XBT_INFO("Route between %s and %s:", name1, name2);
SD_link_t *route = SD_route_get_list(h1, h2);
int route_size = SD_route_get_size(h1, h2);
for (int i = 0; i < route_size; i++)
XBT_INFO(" Link %s: latency = %f, bandwidth = %f", sg_link_name(route[i]), sg_link_latency(route[i]),
sg_link_bandwidth(route[i]));
xbt_free(route);
XBT_INFO("Route latency = %f, route bandwidth = %f", SD_route_get_latency(h1, h2), SD_route_get_bandwidth(h1, h2));
XBT_INFO("Communication time for %f bytes between %s and %s: %f", comm_amount12, name1, name2,
SD_route_get_latency(h1, h2) + comm_amount12 / SD_route_get_bandwidth(h1, h2));
XBT_INFO("Communication time for %f bytes between %s and %s: %f", comm_amount21, name2, name1,
SD_route_get_latency(h2, h1) + comm_amount21 / SD_route_get_bandwidth(h2, h1));
/* creation of the tasks and their dependencies */
SD_task_t taskA = SD_task_create("Task A", NULL, 10.0);
SD_task_t taskB = SD_task_create("Task B", NULL, 40.0);
SD_task_t taskC = SD_task_create("Task C", NULL, 30.0);
SD_task_t taskD = SD_task_create("Task D", NULL, 60.0);
/* try to attach and retrieve user data to a task */
SD_task_set_data(taskA, static_cast<void*>(&comp_amount1));
if (fabs(comp_amount1 - (*(static_cast<double*>(SD_task_get_data(taskA))))) > 1e-12)
XBT_ERROR("User data was corrupted by a simple set/get");
SD_task_dependency_add(NULL, NULL, taskB, taskA);
SD_task_dependency_add(NULL, NULL, taskC, taskA);
SD_task_dependency_add(NULL, NULL, taskD, taskB);
SD_task_dependency_add(NULL, NULL, taskD, taskC);
SD_task_dependency_add(NULL, NULL, taskB, taskC);
try {
SD_task_dependency_add(NULL, NULL, taskA, taskA); /* shouldn't work and must raise an exception */
xbt_die("Hey, I can add a dependency between Task A and Task A!");
} catch (xbt_ex& ex) {
if (ex.category != arg_error)
throw; /* this is a serious error */
}
try {
SD_task_dependency_add(NULL, NULL, taskB, taskA); /* shouldn't work and must raise an exception */
xbt_die("Oh oh, I can add an already existing dependency!");
} catch (xbt_ex& ex) {
if (ex.category != arg_error)
throw;
}
try {
SD_task_dependency_remove(taskA, taskC); /* shouldn't work and must raise an exception */
xbt_die("Dude, I can remove an unknown dependency!");
} catch (xbt_ex& ex) {
if (ex.category != arg_error)
throw;
}
try {
SD_task_dependency_remove(taskC, taskC); /* shouldn't work and must raise an exception */
xbt_die("Wow, I can remove a dependency between Task C and itself!");
} catch (xbt_ex& ex) {
if (ex.category != arg_error)
throw;
}
/* if everything is ok, no exception is forwarded or rethrown by main() */
/* watch points */
SD_task_watch(taskD, SD_DONE);
SD_task_watch(taskB, SD_DONE);
SD_task_unwatch(taskD, SD_DONE);
/* scheduling parameters */
host_list[0] = h1;
host_list[1] = h2;
computation_amount[0] = comp_amount1;
computation_amount[1] = comp_amount2;
communication_amount[1] = comm_amount12;
communication_amount[2] = comm_amount21;
/* estimated time */
SD_task_t task = taskD;
XBT_INFO("Estimated time for '%s': %f", SD_task_get_name(task), SD_task_get_execution_time(task, 2, host_list,
computation_amount, communication_amount));
SD_task_schedule(taskA, 2, host_list, computation_amount, communication_amount, -1);
SD_task_schedule(taskB, 2, host_list, computation_amount, communication_amount, -1);
SD_task_schedule(taskC, 2, host_list, computation_amount, communication_amount, -1);
SD_task_schedule(taskD, 2, host_list, computation_amount, communication_amount, -1);
std::set<SD_task_t> *changed_tasks = simgrid::sd::simulate(-1.0);
for (auto task: *changed_tasks){
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_DEBUG("Destroying tasks...");
SD_task_destroy(taskA);
SD_task_destroy(taskB);
SD_task_destroy(taskC);
SD_task_destroy(taskD);
XBT_DEBUG("Tasks destroyed. Exiting SimDag...");
SD_exit();
return 0;
}
