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;
}
/*----------------------------------------------------------------------*/
void test_init_TF()
{
/* TF卡 */
TCHAR *path = "0:";
LCD_P8x16Str(0,0, (BYTE*)"TF..");
if (!SD_init())
{
/* 挂载TF卡文件系统 */
if (FR_OK == f_mount(&fatfs1, path, 1))
{
/* 文件读写测试 */
if (!test_file_system())
{
g_devices_init_status.TFCard_is_OK = 1;
}
}
}
if (g_devices_init_status.TFCard_is_OK)
{
LCD_P8x16Str(0,0, (BYTE*)"TF..OK");
}
else
{
LCD_P8x16Str(0,0, (BYTE*)"TF..NOK");
suicide();
}
}
int main(int argc, char **argv)
{
int i, j;
xbt_os_timer_t timer = xbt_os_timer_new();
SD_init(&argc, argv);
SD_create_environment(argv[1]);
sg_host_t *hosts = sg_host_list();
int host_count = sg_host_count();
/* Random number initialization */
srand( (int) (xbt_os_time()*1000) );
do {
i = rand()%host_count;
j = rand()%host_count;
} while(i==j);
sg_host_t h1 = hosts[i];
sg_host_t h2 = hosts[j];
printf("%d\tand\t%d\t\t",i,j);
xbt_os_cputimer_start(timer);
SD_route_get_list(h1, h2);
xbt_os_cputimer_stop(timer);
printf("%f\n", xbt_os_timer_elapsed(timer) );
xbt_free(hosts);
SD_exit();
return 0;
}
int main(int argc, char **argv)
{
unsigned int ctr;
const SD_workstation_t *workstations;
int total_nworkstations;
xbt_dict_t current_storage_list;
char *mount_name;
char *storage_name;
xbt_dict_cursor_t cursor = NULL;
SD_init(&argc, argv);
/* Set the workstation model to default, as storage is not supported by the
* ptask_L07 model yet.
*/
SD_config("host/model", "default");
SD_create_environment(argv[1]);
workstations = SD_workstation_get_list();
total_nworkstations = SD_workstation_get_number();
for (ctr=0; ctr<total_nworkstations;ctr++){
current_storage_list = SD_workstation_get_mounted_storage_list(workstations[ctr]);
xbt_dict_foreach(current_storage_list,cursor,mount_name,storage_name)
XBT_INFO("Workstation '%s' mounts '%s'",
SD_workstation_get_name(workstations[ctr]), mount_name);
xbt_dict_free(¤t_storage_list);
}
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;
}
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)
{
int i;
const char *user_data = "some user_data";
const SD_link_t *links;
/* initialization of SD */
SD_init(&argc, argv);
/* creation of the environment */
SD_create_environment(argv[1]);
links = SD_link_get_list();
int count = SD_link_get_number();
XBT_INFO("Link count: %d", count);
qsort((void *)links, count, sizeof(SD_link_t), cmp_link);
for(i=0; i<SD_link_get_number();i++){
XBT_INFO("%s: latency = %.5f, bandwidth = %f",
SD_link_get_name(links[i]),
SD_link_get_current_latency(links[i]),
SD_link_get_current_bandwidth(links[i]));
SD_link_set_data(links[i], (void*) user_data);
if(strcmp(user_data, (const char*)SD_link_get_data(links[i]))){
XBT_ERROR("User data was corrupted.");
}
}
SD_exit();
return 0;
}
int main() {
char ret;
USART_init(51);
USART_printstr("\r\n");
USART_println("Initializing");
USART_printstr(" SPI...");
SPI_init();
USART_println("done");
USART_printstr(" SD...");
if ((ret = SD_init())) {
USART_printstr("error: ");
USART_printhex(ret);
USART_printstr("\r\n");
return -1;
}
USART_println("done");
USART_printstr(" FAT16...");
if ((ret = FAT16_init())) {
USART_printstr("error: ");
USART_printhex(ret);
USART_printstr("\r\n");
return -1;
}
USART_println("done");
return 0;
}
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;
}
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 > 2, "Usage: %s platform_file dot_file [trace_file]"
"example: %s ../2clusters.xml dag.dot dag.mytrace", argv[0], argv[0]);
/* 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;
char *last = strrchr(argv[2], '.');
tracefilename = bprintf("%.*s.trace", (int) (last == NULL ? strlen(argv[2]) : last - argv[2]),argv[2]);
if (argc == 4)
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);
}
//Init Msg_Init From Ruby
static void sd_init(VALUE Class, VALUE args)
{
char **argv = NULL;
const char *tmp;
int argc, type, i;
VALUE *ptr;
type = TYPE(args);
if (type != T_ARRAY) {
rb_raise(rb_eRuntimeError, "Bad Argument to SD_init");
return;
}
ptr = RARRAY_PTR(args);
argc = RARRAY_LEN(args);
argc++;
argv = xbt_new0(char *, argc);
argv[0] = strdup("ruby");
for (i = 0; i < argc - 1; i++) {
VALUE value = ptr[i];
type = TYPE(value);
tmp = RSTRING_PTR(value);
argv[i + 1] = strdup(tmp);
}
SD_init(&argc, argv);
free(argv);
// XBT_INFO("SD Init...Done");
printf("SD Init...Done\n");
return;
}
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)
{
xbt_dict_cursor_t cursor = NULL;
char *key, *data;
char noexist[] = "NoProp";
const char *value;
char exist[] = "Hdd";
/* SD initialization */
SD_init(&argc, argv);
xbt_assert(argc > 1, "Usage: %s platform_file\n\tExample: %s ../../platforms/prop.xml", argv[0], argv[0]);
SD_create_environment(argv[1]);
/* init of platform elements */
sg_host_t h1 = sg_host_by_name("host1");
sg_host_t h2 = sg_host_by_name("host2");
const char *name1 = sg_host_get_name(h1);
const char *name2 = sg_host_get_name(h2);
/* Get the property list of 'host1' */
XBT_INFO("Property list for host %s", name1);
xbt_dict_t props = sg_host_get_properties(h1);
/* Trying to set a new property */
xbt_dict_set(props, "NewProp", strdup("newValue"), NULL);
/* Print the properties of 'host1' */
xbt_dict_foreach(props, cursor, key, data) {
XBT_INFO("\tProperty: %s has value: %s", key, data);
}
/* 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 */
if (argc < 2) {
XBT_INFO("Usage: %s platform_file dot_file ", argv[0]);
XBT_INFO("example: %s ../2clusters.xml ptg.dot", argv[0]);
exit(1);
}
/* 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);
}
int main(int argc, char **argv)
{
xbt_dynar_t dax;
unsigned int cursor;
SD_task_t task;
/* SD initialization */
SD_init(&argc, argv);
/* Check our arguments */
xbt_assert(argc > 2, "Usage: %s platform_file dax_file [jedule_file]\n"
"\tExample: %s simulacrum_7_hosts.xml Montage_25.xml Montage_25.jed", argv[0], argv[0]);
char *last = strrchr(argv[2], '.');
char * tracefilename = bprintf("%.*s.trace",(int) (last == NULL ? strlen(argv[2]):last - argv[2]), argv[2]);
if (argc == 4)
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)
{
char *platformFile = NULL;
unsigned int totalHosts, totalLinks;
int timings=0;
int version = 4;
const char *link_ctn = "link_ctn";
unsigned int i;
xbt_dict_t props = NULL;
xbt_dict_cursor_t cursor = NULL;
xbt_lib_cursor_t cursor_src = NULL;
xbt_lib_cursor_t cursor_dst = NULL;
char *src,*dst,*key,*data;
sg_netcard_t value1;
sg_netcard_t value2;
const sg_host_t *hosts;
const SD_link_t *links;
xbt_os_timer_t parse_time = xbt_os_timer_new();
SD_init(&argc, argv);
if (parse_cmdline(&timings, &platformFile, argc, argv) || !platformFile) {
xbt_die("Invalid command line arguments: expected [--timings] platformFile");
}
XBT_DEBUG("%d,%s", timings, platformFile);
create_environment(parse_time, platformFile);
if (timings) {
XBT_INFO("Parsing time: %fs (%zu hosts, %d links)", xbt_os_timer_elapsed(parse_time),
sg_host_count(), sg_link_count());
} else {
printf("<?xml version='1.0'?>\n");
printf("<!DOCTYPE platform SYSTEM \"http://simgrid.gforge.inria.fr/simgrid/simgrid.dtd\">\n");
printf("<platform version=\"%d\">\n", version);
printf("<AS id=\"AS0\" routing=\"Full\">\n");
// Hosts
totalHosts = sg_host_count();
hosts = sg_host_list();
qsort((void *) hosts, totalHosts, sizeof(sg_host_t), name_compare_hosts);
for (i = 0; i < totalHosts; i++) {
printf(" <host id=\"%s\" speed=\"%.0f\"", sg_host_get_name(hosts[i]), sg_host_speed(hosts[i]));
props = sg_host_get_properties(hosts[i]);
if (sg_host_core_count(hosts[i])>1) {
printf(" core=\"%d\"", sg_host_core_count(hosts[i]));
}
if (props && !xbt_dict_is_empty(props)) {
printf(">\n");
xbt_dict_foreach(props, cursor, key, data) {
printf(" <prop id=\"%s\" value=\"%s\"/>\n", key, data);
}
printf(" </host>\n");
} else {
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;
}
/* 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)
{
unsigned int ctr;
SD_task_t task;
xbt_dynar_t changed_tasks;
SD_init(&argc, argv);
SD_create_environment(argv[1]);
const sg_host_t *hosts = sg_host_list();
SD_task_t t1 = SD_task_create_comp_seq("t1", NULL, 25000000);
SD_task_t c1 = SD_task_create_comm_e2e("c1", NULL, 125000000);
SD_task_t t2 = SD_task_create_comp_seq("t2", NULL, 25000000);
SD_task_t c2 = SD_task_create_comm_e2e("c2", NULL, 62500000);
SD_task_t t3 = SD_task_create_comp_seq("t3", NULL, 25000000);
SD_task_t c3 = SD_task_create_comm_e2e("c3", NULL, 31250000);
SD_task_t t4 = SD_task_create_comp_seq("t4", NULL, 25000000);
/* Add dependencies: t1->c1->t2->c2->t3 */
SD_task_dependency_add(NULL, NULL, t1, c1);
SD_task_dependency_add(NULL, NULL, c1, t2);
SD_task_dependency_add(NULL, NULL, t2, c2);
SD_task_dependency_add(NULL, NULL, c2, t3);
SD_task_dependency_add(NULL, NULL, t3, c3);
SD_task_dependency_add(NULL, NULL, c3, t4);
/* Schedule tasks t1 and w3 on first host, t2 on second host */
/* Transfers are auto-scheduled */
SD_task_schedulel(t1, 1, hosts[0]);
SD_task_schedulel(t2, 1, hosts[1]);
SD_task_schedulel(t3, 1, hosts[0]);
SD_task_schedulel(t4, 1, hosts[1]);
/* Add some watchpoint upon task completion */
SD_task_watch(t1, SD_DONE);
SD_task_watch(c1, SD_DONE);
SD_task_watch(t2, SD_DONE);
SD_task_watch(c2, SD_DONE);
SD_task_watch(t3, SD_DONE);
SD_task_watch(c3, SD_DONE);
SD_task_watch(t4, SD_DONE);
while (!xbt_dynar_is_empty((changed_tasks = SD_simulate(-1.0)))) {
XBT_INFO("link1: bw=%.0f, lat=%f", SD_route_get_bandwidth(hosts[0], hosts[1]),
SD_route_get_latency(hosts[0], hosts[1]));
XBT_INFO("Jupiter: speed=%.0f", sg_host_speed(hosts[0])* sg_host_get_available_speed(hosts[0]));
XBT_INFO("Tremblay: speed=%.0f", sg_host_speed(hosts[1])* sg_host_get_available_speed(hosts[1]));
xbt_dynar_foreach(changed_tasks, ctr, task) {
XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task),
SD_task_get_start_time(task), SD_task_get_finish_time(task));
if (SD_task_get_state(task)==SD_DONE)
SD_task_destroy(task);
}
}
int main(int argc, char **argv)
{
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 {
void sys_init() {
int status = 0;
//Set SD card clock to 10 KHz.
Clock_1_SetDivider(39); //Source clock 400KHz. Divider setting 39 (+ 1)
/* Place your initialization/startup code here (e.g. MyInst_Start()) */
SPIM_Start();
status = SD_init();
//Not able to init SD card.
//assert(status == 0);
//Boost the SD card clocks to 100 KHz.
Clock_1_SetDivider(3); //Source clock 400KHz. Divider setting 3 (+ 1).
}
/* 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 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);
}
/* 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(void)
{
WdtGo(T3CON_ENABLE_DIS);//stop watch-dog
uart_init();
led_init();
Radio_init();//inicializuje radio prenos
SD_init();//nacita kartu a vytvori subor prijaty cez radio prenos
for(i=0; i<29; i++) {
Radio_recieve();//pocka na prijatie jedneho paketu
if (RIE_Response == RIE_Success)
{
printf("\n\r-> %s \n@ RSSI %d ",Buffer,(int)RSSI);
fr = f_printf(&fil,"\n\r-> %s \n@ RSSI %d \n",Buffer,(int)RSSI);
}
else
{
printf("\n\r-> ERROR");
fr = f_printf(&fil,"\n\r-> ERROR");
}
}
RIE_Response = RadioTerminateRadioOp();
fr=f_close(&fil);//koiec zapisu na kartu
printf("\nzatvaram\n");
if(fr)printf("chyba pri zatvarani suboru %d\n",fr);
while (1)//ukonceny zapis
{
DioTgl(pADI_GP4,BIT2);
Delay();
}
}