/** @brief Displays debugging informations about a workstation */
void SD_workstation_dump(SD_workstation_t ws)
{
xbt_dict_t props;
xbt_dict_cursor_t cursor=NULL;
char *key,*data;
SD_task_t task = NULL;
XBT_INFO("Displaying workstation %s", SD_workstation_get_name(ws));
XBT_INFO(" - power: %.0f", SD_workstation_get_power(ws));
XBT_INFO(" - available power: %.2f", SD_workstation_get_available_power(ws));
switch (sg_host_sd(ws)->access_mode){
case SD_WORKSTATION_SHARED_ACCESS:
XBT_INFO(" - access mode: Space shared");
break;
case SD_WORKSTATION_SEQUENTIAL_ACCESS:
XBT_INFO(" - access mode: Exclusive");
task = SD_workstation_get_current_task(ws);
if(task)
XBT_INFO(" current running task: %s",
SD_task_get_name(task));
else
XBT_INFO(" no task running");
break;
default: break;
}
props = SD_workstation_get_properties(ws);
if (!xbt_dict_is_empty(props)){
XBT_INFO(" - properties:");
xbt_dict_foreach(props,cursor,key,data) {
XBT_INFO(" %s->%s",key,data);
}
/*
* Return a rough estimation of what would be the execution time of task given
* as input on a given number of workstations. The task has to be of kind
* SD_TASK_COMP_PAR_AMDAHL, as Amdahl's law is applied to get this estimation.
* It also assumes a fully homogeneous set of workstations as no distinction is
* made within the whole set.
*/
double SD_task_estimate_execution_time(SD_task_t task, int nworkstations){
const SD_workstation_t *workstations = SD_workstation_get_list();
double amount, alpha, power, estimate;
amount = SD_task_get_amount(task);
alpha = SD_task_get_alpha(task);
power = SD_workstation_get_power(workstations[0]);
estimate = (alpha + (1 - alpha)/nworkstations) * (amount/power);
XBT_DEBUG("Estimation for task %s is: %f seconds",
SD_task_get_name(task), estimate);
return estimate;
}
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 {
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)
{
char *platformFile = NULL;
int totalHosts, totalLinks;
int timings=0;
int downgrade = 0;
int version = 3;
const char *link_ctn = link_ctn_v3;
unsigned int i;
xbt_dict_t props = NULL;
xbt_dict_cursor_t cursor = NULL;
xbt_lib_cursor_t cursor_src = NULL;
xbt_lib_cursor_t cursor_dst = NULL;
char *src,*dst,*key,*data;
sg_routing_edge_t value1;
sg_routing_edge_t value2;
const SD_workstation_t *hosts;
const SD_link_t *links;
xbt_os_timer_t parse_time = xbt_os_timer_new();
setvbuf(stdout, NULL, _IOLBF, 0);
SD_init(&argc, argv);
if (parse_cmdline(&timings, &downgrade, &platformFile, argc, argv) || !platformFile) {
xbt_die("Invalid command line arguments: expected [--timings|--downgrade] platformFile");
}
XBT_DEBUG("%d,%d,%s", timings, downgrade, platformFile);
if (downgrade) {
version = 2;
link_ctn = link_ctn_v2;
}
create_environment(parse_time, platformFile);
if (timings) {
XBT_INFO("Parsing time: %fs (%d hosts, %d links)",
xbt_os_timer_elapsed(parse_time),SD_workstation_get_number(),SD_link_get_number());
} else {
printf("<?xml version='1.0'?>\n");
printf("<!DOCTYPE platform SYSTEM \"http://simgrid.gforge.inria.fr/simgrid.dtd\">\n");
printf("<platform version=\"%d\">\n", version);
if (!downgrade)
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_is_empty(props)) {
printf(">\n");
xbt_dict_foreach(props, cursor, key, data) {
printf(" <prop id=\"%s\" value=\"%s\"/>\n", key, data);
}
printf(" </host>\n");
} else {
