int main(int argc, char **argv)
{
double comm_cost[] = { 0.0, 0.0, 0.0, 0.0 };
double comp_cost[] = { 1.0 };
SD_task_t taskA, taskB;
xbt_dynar_t ret;
SD_init(&argc, argv);
SD_create_environment(argv[1]);
taskA = SD_task_create("Task A", NULL, 1.0);
taskB = SD_task_create("Task B", NULL, 1.0);
SD_task_schedule(taskA, 1, SD_workstation_get_list(), comp_cost,
comm_cost, -1.0);
SD_task_schedule(taskB, 1, SD_workstation_get_list(), comp_cost,
comm_cost, -1.0);
ret = SD_simulate(-1.0);
xbt_dynar_free(&ret);
SD_task_destroy(taskA);
SD_task_destroy(taskB);
XBT_INFO("Simulation time: %f", SD_get_clock());
SD_exit();
return 0;
}
static xbt_dynar_t initDynamicThrottling(int *argc, char *argv[])
{
/* Initialize SD */
SD_init(argc, argv);
/* Check parameters */
checkParameters(*argc,argv);
/* Create environment */
SD_create_environment(argv[1]);
/* Load DAX file */
xbt_dynar_t dax = SD_daxload(argv[2]);
// createDottyFile(dax, argv[2]);
// Schedule DAX
fprintf(stdout, "Scheduling DAX...\n");
scheduleDAX(dax);
fprintf(stdout, "DAX scheduled\n");
xbt_dynar_t ret = SD_simulate(-1);
xbt_dynar_free(&ret);
fprintf(stdout, "Simulation end. Time: %f\n", SD_get_clock());
return dax;
}
int main(int argc, char **argv)
{
double time;
double comm_amount[] = { 0.0, 0.0, 0.0, 0.0 };
double comp_cost[] = { 1.0, 1.0 };
SD_task_t task;
xbt_dynar_t ret;
SD_init(&argc, argv);
SD_create_environment(argv[1]);
task = SD_task_create("partask", NULL, 1.0);
SD_task_schedule(task, 2, SD_workstation_get_list(), comp_cost,
comm_amount, -1.0);
ret = SD_simulate(-1.0);
xbt_dynar_free(&ret);
time = SD_get_clock();
printf("%g\n", time);
fflush(stdout);
SD_task_destroy(task);
SD_exit();
return 0;
}
static void zero_cost_test2(int *argc, char *argv[])
{
double time;
SD_task_t task;
xbt_dynar_t ret;
SD_init(argc, argv);
SD_create_environment(argv[1]);
task = create_root_with_costs();
ret = SD_simulate(-1.0);
xbt_dynar_free(&ret);
SD_task_destroy(task);
SD_application_reinit();
task = create_empty_cost_root();
ret = SD_simulate(-1.0);
xbt_dynar_free(&ret);
SD_task_destroy(task);
ret = SD_simulate(-1.0);
xbt_dynar_free(&ret);
time = SD_get_clock();
printf("%g\n", time);
fflush(stdout);
SD_exit();
}
int main(int argc, char **argv)
{
double comm_cost[] = { 0.0, 0.0, 0.0, 0.0 };
double comp_cost[] = { 1.0 };
SD_task_t taskA, taskB;
xbt_dynar_t ret;
SD_init(&argc, argv);
SD_create_environment(argv[1]);
taskA = SD_task_create("Task A", NULL, 1.0);
taskB = SD_task_create("Task B", NULL, 1.0);
SD_task_schedule(taskA, 1, SD_workstation_get_list(), comp_cost,
comm_cost, -1.0);
SD_task_schedule(taskB, 1, SD_workstation_get_list(), comp_cost,
comm_cost, -1.0);
ret = SD_simulate(-1.0);
xbt_assert(xbt_dynar_length(ret) == 2,
"I was expecting the terminaison of 2 tasks, but I got %lu instead",
xbt_dynar_length(ret));
xbt_dynar_free(&ret);
SD_task_destroy(taskA);
SD_task_destroy(taskB);
XBT_INFO("Simulation time: %f", SD_get_clock());
SD_exit();
return 0;
}
int main(int argc, char **argv)
{
double communication_amount[] = { 0.0, 1.0, 0.0, 0.0 };
double no_cost[] = { 0.0, 0.0 };
SD_task_t task[TASK_NUM];
SD_init(&argc, argv);
SD_create_environment(argv[1]);
SD_task_t root = SD_task_create("Root", NULL, 1.0);
sg_host_t *hosts = sg_host_list();
SD_task_schedule(root, 1, hosts, no_cost, no_cost, -1.0);
for (int i = 0; i < TASK_NUM; i++) {
task[i] = SD_task_create("Comm", NULL, 1.0);
SD_task_schedule(task[i], 2, hosts, no_cost, communication_amount, -1.0);
SD_task_dependency_add(NULL, NULL, root, task[i]);
}
xbt_free(hosts);
SD_simulate(-1.0);
printf("%g\n", SD_get_clock());
fflush(stdout);
for (int i = 0; i < TASK_NUM; i++) {
SD_task_destroy(task[i]);
}
SD_task_destroy(root);
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, 0.0, 1.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);
SD_task_schedule(root, 1, sg_host_list(), no_cost1, no_cost1, -1.0);
SD_task_schedule(task1, 2, sg_host_list(), no_cost, communication_amount1, -1.0);
SD_task_schedule(task2, 2, sg_host_list(), no_cost, communication_amount2, -1.0);
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;
}
/* SimDag Incomplete Test
* Scenario:
* - Create a bunch of tasks
* - schedule only a subset of them (init, A and D)
* - run the simulation
* - Verify that we detect which tasks are not scheduled and show their state.
* The scheduled task A sends 1GB. Simulation time should be
* 1e9/1.25e8 + 1e-4 = 8.0001 seconds
* Task D is scheduled but depends on unscheduled task C.
*/
int main(int argc, char **argv)
{
SD_task_t taskInit;
SD_task_t taskA, taskB, taskC, taskD;
xbt_dynar_t ret;
const SD_workstation_t *workstation;
double communication_amount1 = 1e9;
double no_cost = 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 */
taskInit = SD_task_create("Init", NULL, 1.0);
taskA = SD_task_create("Task A", NULL, 1.0);
taskB = SD_task_create("Task B", NULL, 1.0);
taskC = SD_task_create("Task C", NULL, 1.0);
taskD = SD_task_create("Task D", NULL, 1.0);
/* scheduling parameters */
workstation = SD_workstation_get_list();
SD_task_dependency_add(NULL, NULL, taskInit, taskA);
SD_task_dependency_add(NULL, NULL, taskInit, taskB);
SD_task_dependency_add(NULL, NULL, taskC, taskD);
/* let's launch the simulation! */
SD_task_schedule(taskInit, 1, SD_workstation_get_list(), &no_cost,
&no_cost, -1.0);
SD_task_schedule(taskA, 1, &workstation[0], &no_cost,
&communication_amount1, -1.0);
SD_task_schedule(taskD, 1, &workstation[0], &no_cost,
&communication_amount1, -1.0);
ret = SD_simulate(-1.);
xbt_dynar_free(&ret);
SD_task_destroy(taskA);
SD_task_destroy(taskB);
SD_task_destroy(taskC);
SD_task_destroy(taskD);
SD_task_destroy(taskInit);
XBT_INFO("Simulation time: %f", SD_get_clock());
SD_exit();
return 0;
}
/* Determine how much money has already been spent. Each host/VM has an attribute that sums the cost (#hours*price)
* for each period in which the VM is on.
*/
double compute_budget_consumption(){
double consumed_budget = 0.0;
int i=0;
HostAttribute attr;
const sg_host_t *hosts = sg_host_list ();
int nhosts = sg_host_count ();
for(i=0;i<nhosts;i++){
attr = sg_host_user(hosts[i]);
consumed_budget += attr->total_cost;
if (attr->on_off){
XBT_DEBUG("%s : Account for %d consumed hours", sg_host_get_name(hosts[i]),
(int)(SD_get_clock()-attr->start_time)/3600);
consumed_budget += (((int)(SD_get_clock()-attr->start_time)/3600))*attr->price;
}
}
return consumed_budget;
}
/* Disable a resource, i.e., act as a VM is terminated on a host. This amounts to:
* - setting attributes to 'OFF'
* - Resetting the start time of the host to 0 (just in case)
* - Do some accounting. The time (in seconds) spent since the last time host/VM was started (state set to ON) is
* rounded down (as the first hour is charged on activation) and multiplied by the hour price.
* If a provisioning delay is needed before a VM is actually available for executing task, this function destroys the
* booting task created by the sg_host_start function.
*/
void sg_host_terminate(sg_host_t host){
HostAttribute attr = (HostAttribute) sg_host_user(host);
double duration = SD_get_clock() - attr->start_time;
if (attr->booting)
SD_task_destroy(attr->booting);
attr->on_off = 0;
attr->start_time = 0.0;
attr->total_cost += ((((int) duration / 3600)) * attr->price);
XBT_DEBUG("VM stopped on %s: Total cost is now $%f for this host", sg_host_get_name(host), attr->total_cost);
sg_host_user_set(host, attr);
}
int main(int argc, char **argv)
{
unsigned int ctr;
SD_task_t task;
xbt_dynar_t changed_tasks;
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]);
sg_host_t *hosts = sg_host_list();
/* creation of some typed tasks and their dependencies */
/* chain of five tasks, three compute tasks with two data transfers in between */
SD_task_t taskA = SD_task_create_comp_seq("Task A", NULL, 5e9);
SD_task_t taskB = SD_task_create_comm_e2e("Task B", NULL, 1e7);
SD_task_t taskC = SD_task_create_comp_seq("Task C", NULL, 5e9);
SD_task_t taskD = SD_task_create_comm_e2e("Task D", NULL, 1e7);
SD_task_t 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, 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)))) {
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);
}
/* Basic SimDag Test 5
* Scenario:
* - Create a no-op Init task
* - Create two tasks: send 100kB and compute 10Mflops
* - Schedule them concurrently
* The two tasks should overlap smoothly as they use different resources.
* Simulated time should be:
* MAX(1e5/(1.25e8), 1e7/4e9) = MAX(.0009, .0025) = 0.0025 seconds
*/
int main(int argc, char **argv)
{
/* creation of the tasks and their dependencies */
SD_task_t taskInit;
SD_task_t taskA;
SD_task_t taskB;
xbt_dynar_t ret;
/* scheduling parameters */
double no_cost[] = { 0., 0., 0., 0. };
double amount[] = { 0., 100000., 0., 0. };
double comput[] = { 10000000. };
/* initialization of SD */
SD_init(&argc, argv);
/* creation of the environment */
SD_create_environment(argv[1]);
/* creation of the tasks and their dependencies */
taskInit = SD_task_create("Task Init", NULL, 1.0);
taskA = SD_task_create("Task A", NULL, 1.0);
taskB = SD_task_create("Task B", NULL, 1.0);
/* let's launch the simulation! */
SD_task_schedule(taskInit, 1, SD_workstation_get_list(), no_cost,
no_cost, -1.0);
SD_task_schedule(taskA, 2, SD_workstation_get_list(), no_cost, amount,
-1.0);
SD_task_schedule(taskB, 1, SD_workstation_get_list(), comput, no_cost,
-1.0);
SD_task_dependency_add(NULL, NULL, taskInit, taskA);
SD_task_dependency_add(NULL, NULL, taskInit, taskB);
ret = SD_simulate(-1.0);
xbt_dynar_free(&ret);
SD_task_destroy(taskInit);
SD_task_destroy(taskA);
SD_task_destroy(taskB);
XBT_INFO("Simulation time: %f", SD_get_clock());
SD_exit();
return 0;
}
/* 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);
}
/* SimDag Incomplete Test
* Scenario:
* - Create a bunch of tasks
* - schedule only a subset of them (init, A and D)
* - run the simulation
* - Verify that we detect which tasks are not scheduled and show their state.
* The scheduled task A sends 1GB. Simulation time should be
* 1e9/1.25e8 + 1e-4 = 8.0001 seconds
* Task D is scheduled but depends on unscheduled task C.
*/
int main(int argc, char **argv)
{
/* scheduling parameters */
double communication_amount1 = 1e9;
double no_cost = 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 A", NULL, 1.0);
SD_task_t taskB = SD_task_create("Task B", NULL, 1.0);
SD_task_t taskC = SD_task_create("Task C", NULL, 1.0);
SD_task_t taskD = SD_task_create("Task D", NULL, 1.0);
SD_task_dependency_add(taskInit, taskA);
SD_task_dependency_add(taskInit, taskB);
SD_task_dependency_add(taskC, taskD);
sg_host_t *hosts = sg_host_list();
SD_task_schedule(taskInit, 1, hosts, &no_cost, &no_cost, -1.0);
SD_task_schedule(taskA, 1, &hosts[0], &no_cost, &communication_amount1, -1.0);
SD_task_schedule(taskD, 1, &hosts[0], &no_cost, &communication_amount1, -1.0);
xbt_free(hosts);
/* let's launch the simulation! */
SD_simulate(-1.);
SD_task_destroy(taskA);
SD_task_destroy(taskB);
SD_task_destroy(taskC);
SD_task_destroy(taskD);
SD_task_destroy(taskInit);
XBT_INFO("Simulation time: %f", SD_get_clock());
return 0;
}
/* Build an array that contains all the hosts/VMs that are "approaching their hourly billing cycle" in the platform
* Remark: In the paper by Malawski et al., no details are provided about when a VM is "approaching" the end of a
* paid hour. This is hard coded in the source code of cloudworkflowsim: 90s (provisioner interval, a.k.a period) +
* 1s (optimistic deprovisioning delay)
*/
xbt_dynar_t get_ending_billing_cycle_VMs(double period, double margin){
int i;
const sg_host_t *hosts = sg_host_list ();
int nhosts = sg_host_count ();
HostAttribute attr;
xbt_dynar_t endingVMs = xbt_dynar_new(sizeof(sg_host_t), NULL);
for (i = 0; i < nhosts; i++){
attr = sg_host_user(hosts[i]);
/* To determine how far a VM is from the end of a hourly billing cycle, we compute the time spent between the
* start of the VM and the current, and keep the time spent in the last hour. As times are expressed in seconds,
* it amounts to computing the modulo to 3600s=1h. Then the current VM is selected if this modulo is greater than
* 3600-period-margin.
*/
if (attr->on_off && ((int)(SD_get_clock() - attr->start_time) % 3600) > (3600-period-margin))
xbt_dynar_push(endingVMs, &(hosts[i]));
}
return endingVMs;
}
/*
* 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);
SD_task_schedule(task, 2, sg_host_list(), no_cost, communication_amount, -1.0);
SD_simulate(-1.0);
printf("%g\n", SD_get_clock());
fflush(stdout);
SD_task_destroy(task);
SD_exit();
return 0;
}
/* 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;
}
int main(int argc, char **argv)
{
double comm_amount[] = { 0.0 };
double comp_cost[] = { 1.0 };
SD_init(&argc, argv);
SD_create_environment(argv[1]);
SD_task_t task = SD_task_create("seqtask", NULL, 1.0);
sg_host_t *hosts = sg_host_list();
SD_task_schedule(task, 1, hosts, comp_cost, comm_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;
}
fprintf(dotout, "digraph A {\n");
xbt_dynar_foreach(dot, cursor, task) {
SD_task_dotty(task, dotout);
}
fprintf(dotout, "}\n");
fclose(dotout);
/* Schedule them all on all the first workstation */
XBT_INFO("------------------- Schedule tasks ---------------------------");
const SD_workstation_t *ws_list = SD_workstation_get_list();
int count = SD_workstation_get_number();
xbt_dynar_foreach(dot, cursor, task) {
if (SD_task_get_kind(task) == SD_TASK_COMP_PAR_AMDAHL) {
SD_task_schedulev(task, count, ws_list);
}
}
XBT_INFO
("------------------- Run the schedule ---------------------------");
SD_simulate(-1);
XBT_INFO("Makespan: %f", SD_get_clock());
xbt_dynar_foreach(dot, cursor, task) {
SD_task_destroy(task);
}
xbt_dynar_free_container(&dot);
/* exit */
SD_exit();
return 0;
}
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);
}
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;
}
