/* simple test trying to load a Parallel Task Graph (PTG) as a DOT file. */ int main(int argc, char **argv){ xbt_dynar_t dot; unsigned int cursor; SD_task_t task; /* initialization of SD */ SD_init(&argc, argv); /* Check our arguments */ xbt_assert (argc > 1,"Usage: %s platform_file dot_file example: %s ../2clusters.xml ptg.dot", argv[0], argv[0]); /* creation of the environment */ SD_create_environment(argv[1]); /* load the DOT file */ dot = SD_PTG_dotload(argv[2]); if(dot == NULL){ SD_exit(); xbt_die("No dot load may be you have a cycle in your graph"); } /* Display all the tasks */ XBT_INFO("------------------- Display all tasks of the loaded DAG ---------------------------"); xbt_dynar_foreach(dot, cursor, task) { SD_task_dump(task); }
/* 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; }
int main(int argc, char **argv) { const char *platform_file; const SD_workstation_t *workstations; int ws_nr; SD_workstation_t w1 = NULL; SD_workstation_t w2 = NULL; const char *name1, *name2; int i, j, k; /* initialisation 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(); ws_nr = SD_workstation_get_number(); /* Show routes between all workstation */ for (i = 0; i < ws_nr; i++) { for (j = 0; j < ws_nr; j++) { const SD_link_t *route; int route_size; w1 = workstations[i]; w2 = workstations[j]; name1 = SD_workstation_get_name(w1); name2 = SD_workstation_get_name(w2); 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 (k = 0; k < route_size; k++) { XBT_INFO("\tLink %s: latency = %f, bandwidth = %f", SD_link_get_name(route[k]), SD_link_get_current_latency(route[k]), SD_link_get_current_bandwidth(route[k])); } } } SD_exit(); return 0; }
static void create_environment(xbt_os_timer_t parse_time, const char *platformFile) { try { xbt_os_cputimer_start(parse_time); SD_create_environment(platformFile); xbt_os_cputimer_stop(parse_time); } catch (std::exception& e) { xbt_die("Error while loading %s: %s", platformFile, e.what()); } }
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); } }
static void create_environment(xbt_os_timer_t parse_time, const char *platformFile) { xbt_ex_t e; TRY { xbt_os_cputimer_start(parse_time); SD_create_environment(platformFile); xbt_os_cputimer_stop(parse_time); } CATCH(e) { xbt_die("Error while loading %s: %s", platformFile, e.msg); } }
int main(int argc, char **argv) { xbt_os_timer_t timer = xbt_os_timer_new(); /* initialization of SD */ SD_init(&argc, argv); if (argc > 1) { SD_create_environment(argv[1]); } else { SD_create_environment("../../platforms/One_cluster_no_backbone.xml"); } ws_list = SD_workstation_get_list(); reclaimed = xbt_dynar_new(sizeof(bcast_task_t),xbt_free_ref); xbt_dynar_t done = NULL; xbt_os_cputimer_start(timer); send_one(0,SD_workstation_get_number()); do { if (done != NULL && !xbt_dynar_is_empty(done)) { unsigned int cursor; SD_task_t task; 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); }
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); }
int main(int argc, char **argv) { char *platformFile = NULL; int totalHosts, totalLinks; 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; char **value; xbt_ex_t e; const SD_workstation_t *hosts; const SD_link_t *links; SD_init(&argc, argv); platformFile = argv[1]; XBT_DEBUG("%s", platformFile); TRY { SD_create_environment(platformFile); } CATCH(e) { xbt_die("Error while loading %s: %s",platformFile,e.msg); } printf("<?xml version='1.0'?>\n"); printf("<!DOCTYPE platform SYSTEM \"http://simgrid.gforge.inria.fr/simgrid.dtd\">\n"); printf("<platform version=\"3\">\n"); printf("<AS id=\"AS0\" routing=\"Full\">\n"); // Hosts totalHosts = SD_workstation_get_number(); hosts = SD_workstation_get_list(); qsort((void *) hosts, totalHosts, sizeof(SD_workstation_t), name_compare_hosts); for (i = 0; i < totalHosts; i++) { printf(" <host id=\"%s\" power=\"%.0f\"", SD_workstation_get_name(hosts[i]), SD_workstation_get_power(hosts[i])); props = SD_workstation_get_properties(hosts[i]); if (props && xbt_dict_length(props) > 0) { printf(">\n"); xbt_dict_foreach(props, cursor, key, data) { printf(" <prop id=\"%s\" value=\"%s\"/>\n", key, data); } printf(" </host>\n"); } else {
/* 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; }
int main(int argc, char **argv) { xbt_dynar_t dax, changed; unsigned int cursor; SD_task_t task; /* initialisation of SD */ SD_init(&argc, argv); /* Check our arguments */ if (argc < 3) { XBT_INFO("Usage: %s platform_file dax_file [trace_file]", argv[0]); XBT_INFO ("example: %s ../sd_platform.xml Montage_50.xml Montage_50.mytrace", argv[0]); exit(1); } char *tracefilename; if (argc == 3) { char *last = strrchr(argv[2], '.'); tracefilename = bprintf("%.*s.trace", (int) (last == NULL ? strlen(argv[2]) : last - argv[2]), argv[2]); } else { tracefilename = xbt_strdup(argv[3]); } /* creation of the environment */ SD_create_environment(argv[1]); /* load the DAX file */ dax = SD_daxload(argv[2]); if (!dax){ XBT_ERROR("A problem occurred during DAX parsing (cycle or syntax). Do not continue this test"); free(tracefilename); SD_exit(); exit(255); } /* Display all the tasks */ XBT_INFO ("------------------- Display all tasks of the loaded DAG ---------------------------"); xbt_dynar_foreach(dax, cursor, task) { SD_task_dump(task); }
int main(int argc, char **argv) { const SD_workstation_t *workstations; SD_workstation_t w1; SD_workstation_t w2; const char *name1; const char *name2; xbt_dict_t props; xbt_dict_cursor_t cursor = NULL; char *key, *data; char noexist[] = "NoProp"; const char *value; char exist[] = "Hdd"; /* initialisation of SD */ SD_init(&argc, argv); if (argc < 2) { XBT_INFO("Usage: %s platform_file", argv[0]); XBT_INFO("example: %s sd_platform.xml", argv[0]); exit(1); } SD_create_environment(argv[1]); /* init of platform elements */ 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); /* The host properties can be retrived from all interfaces */ XBT_INFO("Property list for workstation %s", name1); /* Get the property list of the workstation 1 */ props = SD_workstation_get_properties(w1); /* Trying to set a new property */ xbt_dict_set(props, "NewProp", strdup("newValue"), NULL); /* Print the properties of the workstation 1 */ xbt_dict_foreach(props, cursor, key, data) { XBT_INFO("\tProperty: %s has value: %s", key, data); }
int main(int argc, char **argv) { xbt_dynar_t dot, changed; unsigned int cursor; SD_task_t task; /* initialization of SD */ SD_init(&argc, argv); /* Check our arguments */ if (argc < 3) { XBT_INFO("Usage: %s platform_file dot_file [trace_file]", argv[0]); XBT_INFO("example: %s ../2clusters.xml dag.dot dag.mytrace", argv[0]); exit(1); } /* creation of the environment */ SD_create_environment(argv[1]); /* load the DOT file */ dot = SD_dotload(argv[2]); if(dot == NULL){ XBT_CRITICAL("No dot loaded. Do you have a cycle in your graph?"); SD_exit(); exit(2); } char *tracefilename; if (argc == 3) { char *last = strrchr(argv[2], '.'); tracefilename = bprintf("%.*s.trace", (int) (last == NULL ? strlen(argv[2]) : last - argv[2]), argv[2]); } else { tracefilename = xbt_strdup(argv[3]); } /* Display all the tasks */ XBT_INFO ("------------------- Display all tasks of the loaded DAG ---------------------------"); xbt_dynar_foreach(dot, cursor, task) { SD_task_dump(task); }
int main(int argc, char **argv) { xbt_dynar_t dot, changed; unsigned int cursor; SD_task_t task; /* initialization of SD */ SD_init(&argc, argv); /* Check our arguments */ if (argc < 3) { XBT_INFO("Usage: %s platform_file dot_file [trace_file]", argv[0]); XBT_INFO("example: %s ../2clusters.xml dag.dot dag.mytrace", argv[0]); exit(1); } /* creation of the environment */ SD_create_environment(argv[1]); /* load the DOT file and schedule tasks */ dot = SD_dotload_with_sched(argv[2]); if(!dot){ XBT_CRITICAL("The dot file with the provided scheduling is wrong, more information with the option : --log=sd_dotparse.thres:verbose"); SD_exit(); exit(2); } char *tracefilename; if (argc == 3) { char *last = strrchr(argv[2], '.'); tracefilename = bprintf("%.*s.trace", (int) (last == NULL ? strlen(argv[2]) : last - argv[2]), argv[2]); } else { tracefilename = xbt_strdup(argv[3]); } /* Display all the tasks */ XBT_INFO ("------------------- Display all tasks of the loaded DAG ---------------------------"); xbt_dynar_foreach(dot, cursor, task) { SD_task_dump(task); }
int main(int argc, char **argv) { double time; SD_task_t root; SD_task_t task1; SD_task_t task2; 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 }; xbt_dynar_t ret; SD_init(&argc, argv); SD_create_environment(argv[1]); root = SD_task_create("Root", NULL, 1.0); task1 = SD_task_create("Comm 1", NULL, 1.0); task2 = SD_task_create("Comm 2", NULL, 1.0); SD_task_schedule(root, 1, SD_workstation_get_list(), no_cost1, no_cost1, -1.0); SD_task_schedule(task1, 2, SD_workstation_get_list(), no_cost, communication_amount1, -1.0); SD_task_schedule(task2, 2, SD_workstation_get_list(), no_cost, communication_amount2, -1.0); SD_task_dependency_add(NULL, NULL, root, task1); SD_task_dependency_add(NULL, NULL, root, task2); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); 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) { /* 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; }
int main(int argc, char **argv) { /* initialisation of SD */ int size; SD_init(&argc, argv); xbt_lib_cursor_t cursor = NULL; char *key, *data; /* creation of the environment */ SD_create_environment(argv[1]); size = xbt_lib_length(host_lib) + xbt_lib_length(as_router_lib); printf("Workstation number: %d, link number: %d, elmts number: %d\n", SD_workstation_get_number(), SD_link_get_number(), size); xbt_lib_foreach(host_lib, cursor, key, data) { printf(" - Seen: \"%s\" is type : %d\n", key, (int) routing_get_network_element_type(key)); }
int main(int argc, char **argv) { double time; SD_task_t task; xbt_dynar_t ret; double communication_amount[] = { 0.0, 1.0, 2.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, }; double no_cost[] = { 0.0, 0.0, 0.0, 0.0 }; /***************************************/ SD_init(&argc, argv); SD_create_environment(argv[1]); task = SD_task_create("Scatter task", NULL, 1.0); SD_task_schedule(task, 4, SD_workstation_get_list(), no_cost, communication_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; }
/* * 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; }
int main(int argc, char **argv) { const char *user_data = "some user_data"; /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); SD_link_t *links = sg_link_list(); int count = sg_link_count(); XBT_INFO("Link count: %d", count); qsort((void *)links, count, sizeof(SD_link_t), cmp_link); for (int i=0; i < count; i++){ XBT_INFO("%s: latency = %.5f, bandwidth = %f", sg_link_name(links[i]), sg_link_latency(links[i]), sg_link_bandwidth(links[i])); sg_link_data_set(links[i], (void*) user_data); xbt_assert(!strcmp(user_data, (const char*)sg_link_data(links[i])),"User data was corrupted."); } xbt_free(links); 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 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) { 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; }
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; }
int main(int argc, char **argv) { /* initialisation of SD */ SD_workstation_t w1, w2; const SD_workstation_t *workstations; const SD_link_t *route; const char *name1; const char *name2; int route_size, i, j, k; int list_size; #ifdef _XBT_WIN32 setbuf(stderr, NULL); setbuf(stdout, NULL); #else setvbuf(stdout, NULL, _IOLBF, 0); #endif SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); printf("Workstation number: %d, link number: %d\n", SD_workstation_get_number(), SD_link_get_number()); if (argc >= 3) { if (!strcmp(argv[2], "ONE_LINK")) { workstations = SD_workstation_get_list(); w1 = workstations[0]; w2 = workstations[1]; name1 = SD_workstation_get_name(w1); name2 = SD_workstation_get_name(w2); printf("Route between %s and %s\n", name1, name2); route = SD_route_get_list(w1, w2); route_size = SD_route_get_size(w1, w2); printf("Route size %d\n", route_size); for (i = 0; i < route_size; i++) { printf(" Link %s: latency = %f, bandwidth = %f\n", SD_link_get_name(route[i]), SD_link_get_current_latency(route[i]), SD_link_get_current_bandwidth(route[i])); } printf("Route latency = %f, route bandwidth = %f\n", SD_route_get_current_latency(w1, w2), SD_route_get_current_bandwidth(w1, w2)); } if (!strcmp(argv[2], "FULL_LINK")) { workstations = SD_workstation_get_list(); list_size = SD_workstation_get_number(); for (i = 0; i < list_size; i++) { w1 = workstations[i]; name1 = SD_workstation_get_name(w1); for (j = 0; j < list_size; j++) { w2 = workstations[j]; name2 = SD_workstation_get_name(w2); printf("Route between %s and %s\n", name1, name2); route = SD_route_get_list(w1, w2); route_size = SD_route_get_size(w1, w2); printf(" Route size %d\n", route_size); for (k = 0; k < route_size; k++) { printf(" Link %s: latency = %f, bandwidth = %f\n", SD_link_get_name(route[k]), SD_link_get_current_latency(route[k]), SD_link_get_current_bandwidth(route[k])); } printf(" Route latency = %f, route bandwidth = %f\n", SD_route_get_current_latency(w1, w2), SD_route_get_current_bandwidth(w1, w2)); } } } if (!strcmp(argv[2], "PROP")) { printf("SG_TEST_mem: %s\n", SD_workstation_get_property_value(SD_workstation_get_by_name("host1"), "SG_TEST_mem") ); printf("Author: %s\n", SD_as_router_get_property_value("AS0", "author")); printf("AS1: %s\n", SD_as_router_get_property_value("AS1", "name")); printf("AS2: %s\n", SD_as_router_get_property_value("AS2", "name")); } } SD_exit(); return 0; }
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) { 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; }
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) { unsigned int flag, cursor, cursor2; char *platform_file = NULL, *daxname = NULL, *priority=NULL; int total_nworkstations = 0; const SD_workstation_t *workstations = NULL; xbt_dynar_t daxes = NULL, current_dax = NULL; int completed_daxes = 0; SD_task_t task; scheduling_globals_t globals; WorkstationAttribute attr; double total_cost = 0.0, score = 0.0; SD_init(&argc, argv); /* get rid off some logs that are useless */ xbt_log_control_set("sd_daxparse.thresh:critical"); xbt_log_control_set("surf_workstation.thresh:critical"); xbt_log_control_set("root.fmt:[%9.3r]%e[%13c/%7p]%e%m%n"); globals = new_scheduling_globals(); daxes = xbt_dynar_new(sizeof(xbt_dynar_t), NULL); opterr = 0; while (1){ static struct option long_options[] = { {"alg", 1, 0, 'a'}, {"platform", 1, 0, 'b'}, {"dax", 1, 0, 'c'}, {"priority", 1, 0, 'd'}, {"deadline", 1, 0, 'e'}, {"budget", 1, 0, 'f'}, {"price", 1, 0, 'g'}, {"period", 1, 0, 'h'}, {"uh", 1, 0, 'i'}, {"ul", 1, 0, 'j'}, {"provisioning_delay", 1, 0, 'k'}, {"silent", 0, 0, 'y'}, {"dump", 1, 0, 'z'}, {0, 0, 0, 0} }; int option_index = 0; flag = getopt_long (argc, argv, "", long_options, &option_index); /* Detect the end of the options. */ if (flag == -1) break; switch (flag) { case 0: /* If this option set a flag, do nothing else now. */ if (long_options[option_index].flag != 0) break; printf ("option %s", long_options[option_index].name); if (optarg) printf (" with arg %s", optarg); printf ("\n"); break; case 'a': /* Algorithm name */ /* DPDS, WA-DPDS, SPSS, Ours*/ globals->alg = getAlgorithmByName(optarg); break; case 'b': platform_file = optarg; SD_create_environment(platform_file); total_nworkstations = SD_workstation_get_number(); workstations = SD_workstation_get_list(); /* Sort the hosts by name for sake of simplicity */ qsort((void *)workstations,total_nworkstations, sizeof(SD_workstation_t), nameCompareWorkstations); for(cursor=0; cursor<total_nworkstations; cursor++){ SD_workstation_allocate_attribute(workstations[cursor]); } break; case 'c': /* List of DAGs to schedule concurrently (just file names here) */ daxname = optarg; XBT_DEBUG("Loading %s", daxname); current_dax = SD_daxload(daxname); xbt_dynar_foreach(current_dax,cursor,task) { if (SD_task_get_kind(task) == SD_TASK_COMP_SEQ){ SD_task_watch(task, SD_DONE); } SD_task_allocate_attribute(task); SD_task_set_dax_name(task, daxname); } xbt_dynar_push(daxes,¤t_dax); break; case 'd': priority = optarg; if (!strcmp(priority,"random")) globals->priority_method = RANDOM; else if (!strcmp(priority, "sorted")) globals->priority_method = SORTED; else { XBT_ERROR("Unknown priority setting method."); exit(1); } break; case 'e': globals->deadline = atof(optarg); break; case 'f': globals->budget = atof(optarg); break; case 'g': globals->price = atof(optarg); break; case 'h': globals->period = atof(optarg); break; case 'i': globals->uh = atof(optarg); break; case 'j': globals->ul = atof(optarg); break; case 'k': globals->provisioning_delay = atof(optarg); break; case 'y': xbt_log_control_set("root.thresh:critical"); break; case 'z': break; } } /* Display some information about the current run */ XBT_INFO("Algorithm: %s",getAlgorithmName(globals->alg)); XBT_INFO(" Priority method: %s", globals->priority_method ? "SORTED" : "RANDOM"); XBT_INFO(" Dynamic provisioning period: %.0fs", globals->period); XBT_INFO(" Lower utilization threshold: %.2f%%", globals->ul); XBT_INFO(" Upper utilization threshold: %.2f%%", globals->uh); XBT_INFO("Platform: %s (%d potential VMs)", platform_file, SD_workstation_get_number()); XBT_INFO(" VM hourly cost: $%f", globals->price); XBT_INFO(" VM provisioning delay: %.0fs", globals->provisioning_delay); if (ceil(globals->budget/((globals->deadline/3600.)*globals->price))> SD_workstation_get_number()){ XBT_ERROR("The platform file doesn't have enough nodes. Stop here"); exit(1); } /* Assign price and provisioning delay to workstation/VM (for the sake of * simplicity) */ for(cursor=0; cursor<total_nworkstations; cursor++){ SD_workstation_set_price(workstations[cursor], globals->price); SD_workstation_set_provisioning_delay(workstations[cursor], globals->provisioning_delay); } XBT_INFO("Ensemble: %lu DAXes", xbt_dynar_length(daxes)); /* Assign priorities to the DAXes composing the ensemble according to the * chosen method: RANDOM (default) or SORTED. * Then display the result. */ assign_dax_priorities(daxes, globals->priority_method); xbt_dynar_foreach(daxes, cursor, current_dax){ task = get_root(current_dax); XBT_INFO(" %s", SD_task_get_dax_name(task)); XBT_INFO(" Priority: %d", SD_task_get_dax_priority(task)); }