/* Basic SimDag Test 0
* Scenario:
* - Create a no-op Init task
* - Create two communication tasks: 100MB and 1B
* - Schedule them concurrently on the two hosts of the platform
* The two communications occur simultaneously but one is so short that it has no impact on the other.
* Simulated time should be:
* 1e8/1.25e8 + 1e-4 = 0.8001 seconds
* This corresponds to paying latency once and having the full bandwidth for the big message.
*/
int main(int argc, char **argv)
{
/* scheduling parameters */
double communication_amount1[] = { 0, 1e8, 0, 0 };
double communication_amount2[] = { 0, 1, 0, 0 };
const double no_cost[] = { 0.0, 0.0 };
/* initialization of SD */
SD_init(&argc, argv);
/* creation of the environment */
SD_create_environment(argv[1]);
/* creation of the tasks and their dependencies */
SD_task_t taskInit = SD_task_create("Init", NULL, 1.0);
SD_task_t taskA = SD_task_create("Task Comm 1", NULL, 1.0);
SD_task_t taskB = SD_task_create("Task Comm 2", NULL, 1.0);
SD_task_dependency_add(NULL, NULL, taskInit, taskA);
SD_task_dependency_add(NULL, NULL, taskInit, taskB);
sg_host_t *hosts = sg_host_list();
SD_task_schedule(taskInit, 1, hosts, no_cost, no_cost, -1.0);
SD_task_schedule(taskA, 2, hosts, no_cost, communication_amount1, -1.0);
SD_task_schedule(taskB, 2, hosts, no_cost, communication_amount2, -1.0);
xbt_free(hosts);
/* let's launch the simulation! */
SD_simulate(-1.0);
SD_task_destroy(taskInit);
SD_task_destroy(taskA);
SD_task_destroy(taskB);
XBT_INFO("Simulation time: %f", SD_get_clock());
SD_exit();
return 0;
}
/* Basic SimDag Test 4
* Scenario:
* - Create a chain of tasks (Init, A, Fin)
* - Have a 1B communication between two no-op tasks.
* Verify that the tasks are actually simulated in the right order.
* The simulated time should be equal to the network latency: 0.0001 seconds.
*/
int main(int argc, char **argv)
{
/* scheduling parameters */
double no_cost[] = { 0., 0., 0., 0. };
double amount[] = { 0., 1., 0., 0. };
/* SD initialization */
SD_init(&argc, argv);
/* creation of the environment */
SD_create_environment(argv[1]);
/* creation of the tasks and their dependencies */
SD_task_t taskInit = SD_task_create("Task Init", NULL, 1.0);
SD_task_t taskA = SD_task_create("Task A", NULL, 1.0);
SD_task_t taskFin = SD_task_create("Task Fin", NULL, 1.0);
SD_task_dependency_add(NULL, NULL, taskInit, taskA);
SD_task_dependency_add(NULL, NULL, taskA, taskFin);
sg_host_t *hosts = sg_host_list();
SD_task_schedule(taskInit, 1, hosts, no_cost, no_cost, -1.0);
SD_task_schedule(taskA, 2, hosts, no_cost, amount, -1.0);
SD_task_schedule(taskFin, 1, hosts, no_cost, no_cost, -1.0);
xbt_free(hosts);
/* let's launch the simulation! */
SD_simulate(-1.0);
SD_task_destroy(taskInit);
SD_task_destroy(taskA);
SD_task_destroy(taskFin);
XBT_INFO("Simulation time: %f", SD_get_clock());
SD_exit();
return 0;
}
/*
* simple latency test
* send one byte from 0 to 1
*
* this is a test for multiple platforms
* see tesh file for expected output
*/
int main(int argc, char **argv)
{
double communication_amount[] = { 0.0, 1.0, 0.0, 0.0 };
const double no_cost[] = { 0.0, 0.0 };
SD_init(&argc, argv);
SD_create_environment(argv[1]);
SD_task_t task = SD_task_create("Comm 1", NULL, 1.0);
sg_host_t *hosts = sg_host_list();
SD_task_schedule(task, 2, hosts, no_cost, communication_amount, -1.0);
xbt_free(hosts);
SD_simulate(-1.0);
printf("%g\n", SD_get_clock());
fflush(stdout);
SD_task_destroy(task);
SD_exit();
return 0;
}
int main(int argc, char **argv)
{
double communication_amount1[] = { 0.0, 1.0, 0.0, 0.0 };
double communication_amount2[] = { 0.0, 1.0, 0.0, 0.0 };
double no_cost1[] = { 0.0 };
double no_cost[] = { 0.0, 0.0 };
SD_init(&argc, argv);
SD_create_environment(argv[1]);
SD_task_t root = SD_task_create("Root", NULL, 1.0);
SD_task_t task1 = SD_task_create("Comm 1", NULL, 1.0);
SD_task_t task2 = SD_task_create("Comm 2", NULL, 1.0);
sg_host_t *hosts = sg_host_list();
SD_task_schedule(root, 1, hosts, no_cost1, no_cost1, -1.0);
SD_task_schedule(task1, 2, hosts, no_cost, communication_amount1, -1.0);
SD_task_schedule(task2, 2, hosts, no_cost, communication_amount2, -1.0);
xbt_free(hosts);
SD_task_dependency_add(NULL, NULL, root, task1);
SD_task_dependency_add(NULL, NULL, root, task2);
SD_simulate(-1.0);
printf("%g\n", SD_get_clock());
fflush(stdout);
SD_task_destroy(root);
SD_task_destroy(task1);
SD_task_destroy(task2);
SD_exit();
return 0;
}
int main(int argc, char **argv)
{
int i;
const char *platform_file;
const SD_workstation_t *workstations;
int kind;
SD_task_t task, taskA, taskB, taskC;
xbt_dynar_t changed_tasks;
SD_workstation_t workstation_list[2];
double computation_amount[2];
double communication_amount[4] = { 0 };
double rate = -1.0;
SD_workstation_t w1, w2;
/* SD initialization */
SD_init(&argc, argv);
/* xbt_log_control_set("sd.thres=debug"); */
if (argc < 2) {
XBT_INFO("Usage: %s platform_file", argv[0]);
XBT_INFO("example: %s sd_platform.xml", argv[0]);
exit(1);
}
/* creation of the environment */
platform_file = argv[1];
SD_create_environment(platform_file);
/* Change the access mode of the workstations */
workstations = SD_workstation_get_list();
w1 = workstations[0];
w2 = workstations[1];
for (i = 0; i < 2; i++) {
SD_workstation_set_access_mode(workstations[i],
SD_WORKSTATION_SEQUENTIAL_ACCESS);
XBT_INFO("Access mode of %s is %s",
SD_workstation_get_name(workstations[i]),
(SD_workstation_get_access_mode(workstations[i]) ==
SD_WORKSTATION_SEQUENTIAL_ACCESS) ? "sequential" : "shared");
}
/* creation of the tasks and their dependencies */
taskA = SD_task_create_comp_seq("Task A", NULL, 2e9);
taskB = SD_task_create_comm_e2e("Task B", NULL, 2e9);
taskC = SD_task_create_comp_seq("Task C", NULL, 1e9);
TRACE_category ("taskA");
TRACE_category ("taskB");
TRACE_category ("taskC");
TRACE_sd_set_task_category (taskA, "taskA");
TRACE_sd_set_task_category (taskB, "taskB");
TRACE_sd_set_task_category (taskC, "taskC");
/* if everything is ok, no exception is forwarded or rethrown by main() */
/* watch points */
SD_task_watch(taskA, SD_RUNNING);
SD_task_watch(taskB, SD_RUNNING);
SD_task_watch(taskC, SD_RUNNING);
SD_task_watch(taskC, SD_DONE);
/* scheduling parameters */
workstation_list[0] = w1;
workstation_list[1] = w2;
computation_amount[0] = SD_task_get_amount(taskA);
computation_amount[1] = SD_task_get_amount(taskB);
communication_amount[1] = SD_task_get_amount(taskC);
communication_amount[2] = 0.0;
SD_task_schedule(taskA, 1, &w1,
&(computation_amount[0]), SD_SCHED_NO_COST, rate);
SD_task_schedule(taskB, 2, workstation_list,
SD_SCHED_NO_COST, communication_amount, rate);
SD_task_schedule(taskC, 1, &w1,
&(computation_amount[1]), SD_SCHED_NO_COST, rate);
/* let's launch the simulation! */
while (!xbt_dynar_is_empty(changed_tasks = SD_simulate(-1.0))) {
for (i = 0; i < 2; i++) {
task = SD_workstation_get_current_task(workstations[i]);
if (task)
kind = SD_task_get_kind(task);
else {
XBT_INFO("There is no task running on %s",
SD_workstation_get_name(workstations[i]));
continue;
}
switch (kind) {
case SD_TASK_COMP_SEQ:
XBT_INFO("%s is currently running on %s (SD_TASK_COMP_SEQ)",
SD_task_get_name(task),
SD_workstation_get_name(workstations[i]));
break;
case SD_TASK_COMM_E2E:
XBT_INFO("%s is currently running on %s (SD_TASK_COMM_E2E)",
SD_task_get_name(task),
SD_workstation_get_name(workstations[i]));
break;
case SD_TASK_NOT_TYPED:
XBT_INFO("Task running on %s has no type",
SD_workstation_get_name(workstations[i]));
break;
default:
XBT_ERROR("Shouldn't be here");
}
}
xbt_dynar_free_container(&changed_tasks);
}
xbt_dynar_free_container(&changed_tasks);
XBT_DEBUG("Destroying tasks...");
SD_task_destroy(taskA);
SD_task_destroy(taskB);
SD_task_destroy(taskC);
XBT_DEBUG("Tasks destroyed. Exiting SimDag...");
SD_exit();
return 0;
}
qsort((void *) ws_list, totalHosts, sizeof(SD_workstation_t),
name_compare_hosts);
int count = SD_workstation_get_number();
xbt_dynar_foreach(dax, cursor, task) {
if (SD_task_get_kind(task) == SD_TASK_COMP_SEQ) {
if (!strcmp(SD_task_get_name(task), "end"))
SD_task_schedulel(task, 1, ws_list[0]);
else
SD_task_schedulel(task, 1, ws_list[cursor % count]);
}
}
XBT_INFO
("------------------- Run the schedule ---------------------------");
changed = SD_simulate(-1);
xbt_dynar_free_container(&changed);
XBT_INFO
("------------------- Produce the trace file---------------------------");
XBT_INFO("Producing the trace of the run into %s", tracefilename);
FILE *out = fopen(tracefilename, "w");
xbt_assert(out, "Cannot write to %s", tracefilename);
free(tracefilename);
xbt_dynar_foreach(dax, cursor, task) {
int kind = SD_task_get_kind(task);
SD_workstation_t *wsl = SD_task_get_workstation_list(task);
switch (kind) {
case SD_TASK_COMP_SEQ:
fprintf(out, "[%f] %s compute %f # %s\n",
SD_task_get_start_time(task),
int main(int argc, char **argv)
{
int i;
const char *platform_file;
const SD_workstation_t *workstations;
SD_task_t taskA, taskB, taskC, taskD;
xbt_dynar_t changed_tasks;
/* initialization of SD */
SD_init(&argc, argv);
/* xbt_log_control_set("sd.thres=debug"); */
if (argc < 2) {
XBT_INFO("Usage: %s platform_file", argv[0]);
XBT_INFO("example: %s sd_platform.xml", argv[0]);
exit(1);
}
/* creation of the environment */
platform_file = argv[1];
SD_create_environment(platform_file);
/* Change the access mode of the workstations */
workstations = SD_workstation_get_list();
for (i = 0; i < 2; i++) {
SD_workstation_dump(workstations[i]);
SD_workstation_set_access_mode(workstations[i],
SD_WORKSTATION_SEQUENTIAL_ACCESS);
XBT_INFO(" Change access mode of %s to %s",
SD_workstation_get_name(workstations[i]),
(SD_workstation_get_access_mode(workstations[i]) ==
SD_WORKSTATION_SEQUENTIAL_ACCESS) ? "sequential" : "shared");
}
/* Well I changed my mind, I want the second workstation to be shared */
SD_workstation_set_access_mode(workstations[1],
SD_WORKSTATION_SHARED_ACCESS);
XBT_INFO(" Change access mode of %s to %s",
SD_workstation_get_name(workstations[1]),
(SD_workstation_get_access_mode(workstations[1]) ==
SD_WORKSTATION_SEQUENTIAL_ACCESS) ? "sequential" : "shared");
/* creation of the tasks and their dependencies */
taskA = SD_task_create_comp_seq("Task A", NULL, 2e10);
taskB = SD_task_create_comm_e2e("Task B", NULL, 2e8);
taskC = SD_task_create_comp_seq("Task C", NULL, 1e10);
taskD = SD_task_create_comp_seq("Task D", NULL, 1e11);
SD_task_dependency_add("B->C", NULL,taskB, taskC);
/* watch points */
SD_task_watch(taskA, SD_RUNNING);
SD_task_watch(taskB, SD_RUNNING);
SD_task_watch(taskC, SD_RUNNING);
SD_task_watch(taskC, SD_DONE);
SD_task_watch(taskD, SD_DONE);
/* scheduling parameters */
SD_task_schedulel(taskA, 1, workstations[0]);
SD_task_schedulel(taskB, 2, workstations[0], workstations[1]);
SD_task_schedulel(taskC, 1, workstations[1]);
SD_task_schedulel(taskD, 1, workstations[1]);
/* let's launch the simulation! */
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]);
}
xbt_dynar_free(&changed_tasks);
}
xbt_dynar_free(&changed_tasks);
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;
}
int main(int argc, char **argv)
{
unsigned int ctr;
const SD_workstation_t *workstations;
SD_task_t t1, c1, t2, c2, t3, c3, t4, task;
xbt_dynar_t changed_tasks;
SD_init(&argc, argv);
SD_create_environment(argv[1]);
workstations = SD_workstation_get_list();
t1 = SD_task_create_comp_seq("t1", NULL, 25000000);
c1 = SD_task_create_comm_e2e("c1", NULL, 125000000);
t2 = SD_task_create_comp_seq("t2", NULL, 25000000);
c2 = SD_task_create_comm_e2e("c2", NULL, 62500000);
t3 = SD_task_create_comp_seq("t3", NULL, 25000000);
c3 = SD_task_create_comm_e2e("c3", NULL, 31250000);
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, workstations[0]);
SD_task_schedulel(t2, 1, workstations[1]);
SD_task_schedulel(t3, 1, workstations[0]);
SD_task_schedulel(t4, 1, workstations[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_current_bandwidth(workstations[0], workstations[1]),
SD_route_get_current_latency(workstations[0], workstations[1]));
XBT_INFO("Jupiter: power=%.0f",
SD_workstation_get_power(workstations[0])*
SD_workstation_get_available_power(workstations[0]));
XBT_INFO("Tremblay: power=%.0f",
SD_workstation_get_power(workstations[1])*
SD_workstation_get_available_power(workstations[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);
}
xbt_dynar_free_container(&changed_tasks);
}
int main(int argc, char **argv)
{
unsigned int ctr;
const char *platform_file;
const SD_workstation_t *workstations;
SD_task_t task, taskA, taskB, taskC, taskD, taskE;
xbt_dynar_t changed_tasks;
/* initialization of SD */
SD_init(&argc, argv);
/* xbt_log_control_set("sd.thres=debug"); */
if (argc < 2) {
XBT_INFO("Usage: %s platform_file", argv[0]);
XBT_INFO("example: %s sd_platform.xml", argv[0]);
exit(1);
}
/* creation of the environment */
platform_file = argv[1];
SD_create_environment(platform_file);
workstations = SD_workstation_get_list();
/* creation of some typed tasks and their dependencies */
/* chain of five tasks, three compute tasks with two data transfers */
/* in between */
taskA = SD_task_create_comp_seq("Task A", NULL, 5e9);
taskB = SD_task_create_comm_e2e("Task B", NULL, 1e7);
taskC = SD_task_create_comp_seq("Task C", NULL, 5e9);
taskD = SD_task_create_comm_e2e("Task D", NULL, 1e7);
taskE = SD_task_create_comp_seq("Task E", NULL, 5e9);
SD_task_dependency_add(NULL, NULL, taskA, taskB);
SD_task_dependency_add(NULL, NULL, taskB, taskC);
SD_task_dependency_add(NULL, NULL, taskC, taskD);
SD_task_dependency_add(NULL, NULL, taskD, taskE);
/* Add watchpoints on completion of compute tasks */
SD_task_watch(taskA, SD_DONE);
SD_task_watch(taskC, SD_DONE);
SD_task_watch(taskE, SD_DONE);
/* Auto-schedule the compute tasks on three different workstations */
/* Data transfer tasks taskB and taskD are automagically scheduled */
SD_task_schedulel(taskA, 1, workstations[0]);
SD_task_schedulel(taskC, 1, workstations[1]);
SD_task_schedulel(taskE, 1, workstations[0]);
while (!xbt_dynar_is_empty((changed_tasks = SD_simulate(-1.0)))) {
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));
}
/* 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. the rate is then 1.25e8/(2*1e7)=6.25
* Changing the rate is possible before the task execution starts (in SD_RUNNING
* state).
*/
if (SD_task_get_state(taskC) == SD_DONE && SD_task_get_state(taskD) < SD_RUNNING)
SD_task_set_rate(taskD, 6.25);
xbt_dynar_free_container(&changed_tasks);
}
xbt_dynar_foreach(done, cursor, task) {
bcast_task_t bt = SD_task_get_data(task);
if (bt->i != bt->j -1)
send_one(bt->i,bt->j);
if (bt->j != bt->k -1)
send_one(bt->j,bt->k);
if (xbt_dynar_length(reclaimed)<100) {
xbt_dynar_push_as(reclaimed,bcast_task_t,bt);
} else {
free(bt);
}
SD_task_destroy(task);
}
xbt_dynar_free(&done);
}
done=SD_simulate(-1);
} while(!xbt_dynar_is_empty(done));
xbt_os_cputimer_stop(timer);
printf("exec_time:%f\n", xbt_os_timer_elapsed(timer) );
xbt_dynar_free(&done);
xbt_dynar_free(&reclaimed);
SD_exit();
XBT_INFO("Done. Bailing out");
return 0;
}
int main(int argc, char **argv)
{
int i, j;
xbt_dynar_t changed_tasks;
int n_hosts;
const SD_workstation_t *hosts;
SD_task_t taskInit;
SD_task_t PtoPComm1;
SD_task_t PtoPComm2;
SD_task_t ParComp_wocomm;
SD_task_t IntraRedist;
SD_task_t ParComp_wcomm1;
SD_task_t InterRedist;
SD_task_t taskFinal;
SD_task_t ParComp_wcomm2;
SD_workstation_t PtoPcomm1_hosts[2];
SD_workstation_t PtoPcomm2_hosts[2];
double PtoPcomm1_table[] = { 0, 12500000, 0, 0 }; /* 100Mb */
double PtoPcomm2_table[] = { 0, 1250000, 0, 0 }; /* 10Mb */
double ParComp_wocomm_cost[] = { 1e+9, 1e+9, 1e+9, 1e+9, 1e+9 }; /* 1 Gflop per Proc */
double *ParComp_wocomm_table;
SD_workstation_t ParComp_wocomm_hosts[5];
double *IntraRedist_cost;
double *IntraRedist_table;
SD_workstation_t IntraRedist_hosts[5];
double ParComp_wcomm1_cost[] = { 1e+9, 1e+9, 1e+9, 1e+9, 1e+9 }; /* 1 Gflop per Proc */
double *ParComp_wcomm1_table;
SD_workstation_t ParComp_wcomm1_hosts[5];
double *InterRedist_cost;
double *InterRedist_table;
double ParComp_wcomm2_cost[] = { 1e+8, 1e+8, 1e+8, 1e+8, 1e+8 }; /* 1 Gflop per Proc (0.02sec duration) */
SD_workstation_t ParComp_wcomm2_hosts[5];
double final_cost = 5e+9;
double *ParComp_wcomm2_table;
/* initialisation of SD */
SD_init(&argc, argv);
/* creation of the environment */
if (strstr(argv[1],".xml"))
SD_create_environment(argv[1]);
else
xbt_die("Unsupported platform description style (not XML): %s",
argv[1]);
/* getting platform infos */
n_hosts = SD_workstation_get_number();
hosts = SD_workstation_get_list();
/* sorting hosts by hostname */
qsort((void *) hosts, n_hosts, sizeof(SD_workstation_t),
nameCompareHosts);
/* creation of the tasks */
taskInit = SD_task_create("Initial", NULL, 1.0);
PtoPComm1 = SD_task_create("PtoP Comm 1", NULL, 1.0);
PtoPComm2 = SD_task_create("PtoP Comm 2", NULL, 1.0);
ParComp_wocomm = SD_task_create("Par Comp without comm", NULL, 1.0);
IntraRedist = SD_task_create("intra redist", NULL, 1.0);
ParComp_wcomm1 = SD_task_create("Par Comp with comm 1", NULL, 1.0);
InterRedist = SD_task_create("inter redist", NULL, 1.0);
taskFinal = SD_task_create("Final", NULL, 1.0);
ParComp_wcomm2 = SD_task_create("Par Comp with comm 2", NULL, 1.0);
/* creation of the dependencies */
SD_task_dependency_add(NULL, NULL, taskInit, PtoPComm1);
SD_task_dependency_add(NULL, NULL, taskInit, PtoPComm2);
SD_task_dependency_add(NULL, NULL, PtoPComm1, ParComp_wocomm);
SD_task_dependency_add(NULL, NULL, ParComp_wocomm, IntraRedist);
SD_task_dependency_add(NULL, NULL, IntraRedist, ParComp_wcomm1);
SD_task_dependency_add(NULL, NULL, ParComp_wcomm1, InterRedist);
SD_task_dependency_add(NULL, NULL, InterRedist, ParComp_wcomm2);
SD_task_dependency_add(NULL, NULL, ParComp_wcomm2, taskFinal);
SD_task_dependency_add(NULL, NULL, PtoPComm2, taskFinal);
/* scheduling parameters */
/* large point-to-point communication (0.1 sec duration) */
PtoPcomm1_hosts[0] = hosts[0];
PtoPcomm1_hosts[1] = hosts[1];
/* small point-to-point communication (0.01 sec duration) */
PtoPcomm2_hosts[0] = hosts[0];
PtoPcomm2_hosts[1] = hosts[2];
/* parallel task without intra communications (1 sec duration) */
ParComp_wocomm_table = xbt_new0(double, 25);
for (i = 0; i < 5; i++) {
ParComp_wocomm_hosts[i] = hosts[i];
}
/* redistribution within a cluster (small latencies) */
/* each host send (4*2.5Mb =) 10Mb */
/* bandwidth is shared between 5 flows (0.05sec duration) */
IntraRedist_cost = xbt_new0(double, 5);
IntraRedist_table = xbt_new0(double, 25);
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
if (i == j)
IntraRedist_table[i * 5 + j] = 0.;
else
IntraRedist_table[i * 5 + j] = 312500.; /* 2.5Mb */
}
}
for (i = 0; i < 5; i++) {
IntraRedist_hosts[i] = hosts[i];
}
/* parallel task with intra communications */
/* Computation domination (1 sec duration) */
ParComp_wcomm1_table = xbt_new0(double, 25);
for (i = 0; i < 5; i++) {
ParComp_wcomm1_hosts[i] = hosts[i];
}
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
if (i == j)
ParComp_wcomm1_table[i * 5 + j] = 0.;
else
ParComp_wcomm1_table[i * 5 + j] = 312500.; /* 2.5Mb */
}
}
/* inter cluster redistribution (big latency on the backbone) */
/* (0.5sec duration without latency impact) */
InterRedist_cost = xbt_new0(double, 10);
InterRedist_table = xbt_new0(double, 100);
for (i = 0; i < 5; i++) {
InterRedist_table[i * 10 + i + 5] = 1250000.; /* 10Mb */
}
/* parallel task with intra communications */
/* Communication domination (0.1 sec duration) */
ParComp_wcomm2_table = xbt_new0(double, 25);
for (i = 0; i < 5; i++) {
ParComp_wcomm2_hosts[i] = hosts[i + 5];
}
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
if (i == j)
ParComp_wcomm2_table[i * 5 + j] = 0.;
else
ParComp_wcomm2_table[i * 5 + j] = 625000.; /* 5Mb */
}
}
/* Sequential task */
/* scheduling the tasks */
SD_task_schedule(taskInit, 1, hosts, SD_SCHED_NO_COST, SD_SCHED_NO_COST,
-1.0);
SD_task_schedule(PtoPComm1, 2, PtoPcomm1_hosts, SD_SCHED_NO_COST,
PtoPcomm1_table, -1.0);
SD_task_schedule(PtoPComm2, 2, PtoPcomm2_hosts, SD_SCHED_NO_COST,
PtoPcomm2_table, -1.0);
SD_task_schedule(ParComp_wocomm, 5, ParComp_wocomm_hosts,
ParComp_wocomm_cost, ParComp_wocomm_table, -1.0);
SD_task_schedule(IntraRedist, 5, IntraRedist_hosts, IntraRedist_cost,
IntraRedist_table, -1.0);
SD_task_schedule(ParComp_wcomm1, 5, ParComp_wcomm1_hosts,
ParComp_wcomm1_cost, ParComp_wcomm1_table, -1.0);
SD_task_schedule(InterRedist, 10, hosts, InterRedist_cost,
InterRedist_table, -1.0);
SD_task_schedule(ParComp_wcomm2, 5, ParComp_wcomm2_hosts,
ParComp_wcomm2_cost, ParComp_wcomm2_table, -1.0);
SD_task_schedule(taskFinal, 1, &(hosts[9]), &final_cost,
SD_SCHED_NO_COST, -1.0);
/* let's launch the simulation! */
changed_tasks = SD_simulate(-1.0);
XBT_INFO("Simulation time: %f", SD_get_clock());
xbt_dynar_free_container(&changed_tasks);
free(ParComp_wocomm_table);
free(IntraRedist_cost);
free(IntraRedist_table);
free(ParComp_wcomm1_table);
free(InterRedist_cost);
free(InterRedist_table);
free(ParComp_wcomm2_table);
SD_task_destroy(taskInit);
SD_task_destroy(PtoPComm1);
SD_task_destroy(PtoPComm2);
SD_task_destroy(ParComp_wocomm);
SD_task_destroy(IntraRedist);
SD_task_destroy(ParComp_wcomm1);
SD_task_destroy(InterRedist);
SD_task_destroy(ParComp_wcomm2);
SD_task_destroy(taskFinal);
SD_exit();
return 0;
}
int main(int argc, char **argv)
{
double computation_amount[1];
double communication_amount[2] = { 0 };
sg_host_t hosts[1];
/* initialization of SD */
SD_init(&argc, argv);
/* creation of the environment */
SD_create_environment(argv[1]);
/* creation of a single task that will poorly fail when the workstation will stop */
XBT_INFO("First test: COMP_SEQ task");
SD_task_t task = SD_task_create_comp_seq("Poor task", NULL, 2e10);
SD_task_watch(task, SD_FAILED);
SD_task_watch(task, SD_DONE);
XBT_INFO("Schedule task '%s' on 'Faulty Host'", SD_task_get_name(task));
SD_task_schedulel(task, 1, sg_host_by_name("Faulty Host"));
xbt_dynar_t tasks = SD_simulate(-1.0);
xbt_dynar_free(&tasks);
SD_task_dump(task);
XBT_INFO("Task '%s' has failed. %.f flops remain to be done", SD_task_get_name(task),
SD_task_get_remaining_amount(task));
XBT_INFO("let's unschedule task '%s' and reschedule it on the 'Safe Host'", SD_task_get_name(task));
SD_task_unschedule(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_task_dump(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));
SD_task_destroy(task);
task=NULL;
XBT_INFO("Second test: NON TYPED task");
task = SD_task_create("Poor parallel task", NULL, 2e10);
SD_task_watch(task, SD_FAILED);
SD_task_watch(task, SD_DONE);
computation_amount[0] = 2e10;
XBT_INFO("Schedule task '%s' on 'Faulty Host'", SD_task_get_name(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_task_dump(task);
XBT_INFO("Task '%s' has failed. %.f flops remain to be done", SD_task_get_name(task),
SD_task_get_remaining_amount(task));
XBT_INFO("let's unschedule task '%s' and reschedule it on the 'Safe Host'", SD_task_get_name(task));
SD_task_unschedule(task);
hosts[0] = sg_host_by_name("Safe Host");
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_task_dump(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));
SD_task_destroy(task);
SD_exit();
return 0;
}
int main(int argc, char **argv)
{
int i;
unsigned int ctr;
const char *platform_file;
const SD_workstation_t *workstations;
const char *name1;
const char *name2;
double computation_amount1;
double computation_amount2;
double communication_amount12;
double communication_amount21;
const SD_link_t *route;
int route_size;
SD_task_t task, taskA, taskB, taskC, taskD, checkB, checkD;
xbt_dynar_t changed_tasks;
xbt_ex_t ex;
const int workstation_number = 2;
SD_workstation_t workstation_list[2];
double computation_amount[2];
double communication_amount[4] = { 0 };
double rate = -1.0;
SD_workstation_t w1, w2;
/* initialization of SD */
SD_init(&argc, argv);
/* xbt_log_control_set("sd.thres=debug"); */
if (argc < 2) {
XBT_INFO("Usage: %s platform_file", argv[0]);
XBT_INFO("example: %s sd_platform.xml", argv[0]);
exit(1);
}
/* creation of the environment */
platform_file = argv[1];
SD_create_environment(platform_file);
/* test the estimation functions */
workstations = SD_workstation_get_list();
w1 = workstations[0];
w2 = workstations[1];
SD_workstation_set_access_mode(w2, SD_WORKSTATION_SEQUENTIAL_ACCESS);
name1 = SD_workstation_get_name(w1);
name2 = SD_workstation_get_name(w2);
computation_amount1 = 2000000;
computation_amount2 = 1000000;
communication_amount12 = 2000000;
communication_amount21 = 3000000;
XBT_INFO("Computation time for %f flops on %s: %f", computation_amount1,
name1, SD_workstation_get_computation_time(w1,
computation_amount1));
XBT_INFO("Computation time for %f flops on %s: %f", computation_amount2,
name2, SD_workstation_get_computation_time(w2,
computation_amount2));
XBT_INFO("Route between %s and %s:", name1, name2);
route = SD_route_get_list(w1, w2);
route_size = SD_route_get_size(w1, w2);
for (i = 0; i < route_size; i++) {
XBT_INFO(" Link %s: latency = %f, bandwidth = %f",
SD_link_get_name(route[i]),
SD_link_get_current_latency(route[i]),
SD_link_get_current_bandwidth(route[i]));
}
XBT_INFO("Route latency = %f, route bandwidth = %f",
SD_route_get_current_latency(w1, w2),
SD_route_get_current_bandwidth(w1, w2));
XBT_INFO("Communication time for %f bytes between %s and %s: %f",
communication_amount12, name1, name2,
SD_route_get_communication_time(w1, w2, communication_amount12));
XBT_INFO("Communication time for %f bytes between %s and %s: %f",
communication_amount21, name2, name1,
SD_route_get_communication_time(w2, w1, communication_amount21));
/* creation of the tasks and their dependencies */
taskA = SD_task_create("Task A", NULL, 10.0);
taskB = SD_task_create("Task B", NULL, 40.0);
taskC = SD_task_create("Task C", NULL, 30.0);
taskD = SD_task_create("Task D", NULL, 60.0);
/* try to attach and retrieve user data to a task */
SD_task_set_data(taskA, (void*) &computation_amount1);
if (computation_amount1 != (*((double*) SD_task_get_data(taskA))))
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, taskA, taskD); /\* deadlock */
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(ex) {
if (ex.category != arg_error)
RETHROW; /* this is a serious error */
xbt_ex_free(ex);
}
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(ex) {
if (ex.category != arg_error)
RETHROW;
xbt_ex_free(ex);
}
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(ex) {
if (ex.category != arg_error)
RETHROW;
xbt_ex_free(ex);
}
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(ex) {
if (ex.category != arg_error)
RETHROW;
xbt_ex_free(ex);
}
/* 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 */
workstation_list[0] = w1;
workstation_list[1] = w2;
computation_amount[0] = computation_amount1;
computation_amount[1] = computation_amount2;
communication_amount[1] = communication_amount12;
communication_amount[2] = communication_amount21;
/* estimated time */
task = taskD;
XBT_INFO("Estimated time for '%s': %f", SD_task_get_name(task),
SD_task_get_execution_time(task, workstation_number,
workstation_list, computation_amount,
communication_amount));
/* let's launch the simulation! */
SD_task_schedule(taskA, workstation_number, workstation_list,
computation_amount, communication_amount, rate);
SD_task_schedule(taskB, workstation_number, workstation_list,
computation_amount, communication_amount, rate);
SD_task_schedule(taskC, workstation_number, workstation_list,
computation_amount, communication_amount, rate);
SD_task_schedule(taskD, workstation_number, workstation_list,
computation_amount, communication_amount, rate);
changed_tasks = SD_simulate(-1.0);
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));
}
