int main(int argc, char *argv[]){ MSG_init(&argc, argv); xbt_assert(argc == 2); MSG_create_environment(argv[1]); xbt_dynar_t hosts_dynar = MSG_hosts_as_dynar(); msg_host_t pm0 = xbt_dynar_get_as(hosts_dynar, 0, msg_host_t); launch_master(pm0); int res = MSG_main(); XBT_INFO("Bye (simulation time %g)", MSG_get_clock()); xbt_dynar_free(&hosts_dynar); return !(res == MSG_OK); }
/** @brief Merge dynar d2 into d1 * * \param d1 dynar to keep * \param d2 dynar to merge into d1. This dynar is free at end. */ void xbt_dynar_merge(xbt_dynar_t *d1, xbt_dynar_t *d2) { if((*d1)->elmsize != (*d2)->elmsize) xbt_die("Element size must are not equal"); const unsigned long elmsize = (*d1)->elmsize; void *ptr = _xbt_dynar_elm((*d2), 0); _xbt_dynar_resize(*d1, (*d1)->size + (*d2)->size); void *elm = _xbt_dynar_elm((*d1), (*d1)->used); memcpy(elm, ptr, ((*d2)->size)*elmsize); (*d1)->used += (*d2)->used; (*d2)->used = 0; xbt_dynar_free(d2); }
JNIEXPORT int JNICALL Java_org_simgrid_msg_Comm_waitAny(JNIEnv *env, jclass cls, jobjectArray jcomms) { int count; msg_comm_t* comms = jarray_to_commArray(env, jcomms, &count); if (not comms) return -1; xbt_dynar_t dyn = xbt_dynar_new(sizeof(msg_comm_t),nullptr); for (int i=0; i<count; i++) { xbt_dynar_push(dyn, &(comms[i])); } int rank = MSG_comm_waitany(dyn); delete[] comms; xbt_dynar_free(&dyn); return rank; }
/* 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) { SD_task_t taskInit; SD_task_t taskA; SD_task_t taskB; xbt_dynar_t ret; /* 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 */ taskInit = SD_task_create("Init", NULL, 1.0); taskA = SD_task_create("Task Comm 1", NULL, 1.0); taskB = SD_task_create("Task Comm 2", 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, communication_amount1, -1.0); SD_task_schedule(taskB, 2, SD_workstation_get_list(), no_cost, communication_amount2, -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; }
NetworkIBModel::NetworkIBModel() : NetworkSmpiModel() { m_haveGap=false; active_nodes=NULL; const char* IB_factors_string=sg_cfg_get_string("smpi/IB_penalty_factors"); xbt_dynar_t radical_elements = xbt_str_split(IB_factors_string, ";"); if(xbt_dynar_length(radical_elements)!=3) surf_parse_error("smpi/IB_penalty_factors should be provided and contain 3 elements, semi-colon separated : for example 0.965;0.925;1.35"); Be = atof(xbt_dynar_get_as(radical_elements, 0, char *)); Bs = atof(xbt_dynar_get_as(radical_elements, 1, char *)); ys = atof(xbt_dynar_get_as(radical_elements, 2, char *)); xbt_dynar_free(&radical_elements); }
int main(int argc, char **argv) { MSG_init(&argc, argv); MSG_create_environment(argv[1]); xbt_dynar_t hosts = MSG_hosts_as_dynar(); MSG_function_register("host", host); unsigned long nb_hosts = xbt_dynar_length(hosts); XBT_INFO("Number of host '%lu'",nb_hosts); for(int i = 0 ; i < nb_hosts; i++){ MSG_process_create("host", host, NULL, xbt_dynar_get_as(hosts,i,msg_host_t)); } xbt_dynar_free(&hosts); int res = MSG_main(); XBT_INFO("Simulation time %g", MSG_get_clock()); return res != MSG_OK; }
int main(int argc, char *argv[]) { msg_error_t res = MSG_OK; MSG_init(&argc, argv); xbt_assert(argc > 1, "Usage: %s platform_file\n\tExample: %s msg_platform.xml\n", argv[0], argv[0]); MSG_create_environment(argv[1]); /** - Load the platform description */ MSG_function_register("dream_master", dream_master); /** - Create and deploy the @ref dream_master */ xbt_dynar_t hosts = MSG_hosts_as_dynar(); MSG_process_create("dream_master", dream_master, NULL, xbt_dynar_getfirst_as(hosts, msg_host_t)); xbt_dynar_free(&hosts); res = MSG_main(); /** - Run the simulation */ XBT_INFO("Simulation time %g", MSG_get_clock()); return res != MSG_OK; }
/** Receiver function */ int receiver(int argc, char *argv[]) { int id = -1; int i; char mailbox[80]; xbt_dynar_t comms = xbt_dynar_new(sizeof(msg_comm_t), NULL); int tasks = atof(argv[2]); msg_task_t *task = xbt_new(msg_task_t, tasks); _XBT_GNUC_UNUSED int read; read = sscanf(argv[1], "%d", &id); xbt_assert(read, "Invalid argument %s\n", argv[1]); sprintf(mailbox, "receiver-%d", id); MSG_process_sleep(10); msg_comm_t res_irecv; for (i = 0; i < tasks; i++) { XBT_INFO("Wait to receive task %d", i); task[i] = NULL; res_irecv = MSG_task_irecv(&task[i], mailbox); xbt_dynar_push_as(comms, msg_comm_t, res_irecv); } /* Here we are waiting for the receiving of all communications */ msg_task_t task_com; while (!xbt_dynar_is_empty(comms)) { _XBT_GNUC_UNUSED msg_error_t err; xbt_dynar_remove_at(comms, MSG_comm_waitany(comms), &res_irecv); task_com = MSG_comm_get_task(res_irecv); MSG_comm_destroy(res_irecv); XBT_INFO("Processing \"%s\"", MSG_task_get_name(task_com)); MSG_task_execute(task_com); XBT_INFO("\"%s\" done", MSG_task_get_name(task_com)); err = MSG_task_destroy(task_com); xbt_assert(err == MSG_OK, "MSG_task_destroy failed"); } xbt_dynar_free(&comms); xbt_free(task); /* Here we tell to sender that all tasks are done */ sprintf(mailbox, "finalize"); res_irecv = MSG_task_isend(MSG_task_create(NULL, 0, 0, NULL), mailbox); MSG_comm_wait(res_irecv, -1); MSG_comm_destroy(res_irecv); XBT_INFO("I'm done. See you!"); return 0; } /* end_of_receiver */
static int sender(int argc, char *argv[]) { xbt_assert(argc==6, "This function expects 5 parameters from the XML deployment file"); long number_of_tasks = xbt_str_parse_int(argv[1], "Invalid amount of tasks: %s"); double task_comp_size = xbt_str_parse_double(argv[2], "Invalid computational size: %s"); double task_comm_size = xbt_str_parse_double(argv[3], "Invalid communication size: %s"); long receivers_count = xbt_str_parse_int(argv[4], "Invalid amount of receivers: %s"); int diff_com = xbt_str_parse_int(argv[5], "Invalid value for diff_comm: %s"); xbt_dynar_t comms = xbt_dynar_new(sizeof(msg_comm_t), NULL); /* First pack the communications in the dynar */ for (int i = 0; i < number_of_tasks; i++) { double coef = (diff_com == 0) ? 1 : (i + 1); char mailbox[80]; char taskname[80]; snprintf(mailbox,79, "receiver-%ld", (i % receivers_count)); snprintf(taskname,79, "Task_%d", i); msg_task_t task = MSG_task_create(taskname, task_comp_size, task_comm_size / coef, NULL); msg_comm_t comm = MSG_task_isend(task, mailbox); xbt_dynar_push_as(comms, msg_comm_t, comm); XBT_INFO("Send to receiver-%ld %s comm_size %f", i % receivers_count, taskname, task_comm_size / coef); } /* Here we are waiting for the completion of all communications */ while (xbt_dynar_is_empty(comms) == 0) { msg_comm_t comm; xbt_dynar_remove_at(comms, MSG_comm_waitany(comms), &comm); MSG_comm_destroy(comm); } xbt_dynar_free(&comms); /* Here we are waiting for the completion of all tasks */ for (int i = 0; i < receivers_count; i++) { msg_task_t task = NULL; msg_comm_t comm = MSG_task_irecv(&task, "finalize"); msg_error_t res_wait = MSG_comm_wait(comm, -1); xbt_assert(res_wait == MSG_OK, "MSG_comm_wait failed"); MSG_comm_destroy(comm); MSG_task_destroy(task); } XBT_INFO("Goodbye now!"); return 0; }
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; }
/** Test function */ msg_error_t test_all(const char *platform_file) { msg_error_t res = MSG_OK; xbt_dynar_t all_hosts; msg_host_t first_host; MSG_config("host/model", "ptask_L07"); MSG_create_environment(platform_file); all_hosts = MSG_hosts_as_dynar(); first_host = xbt_dynar_getfirst_as(all_hosts,msg_host_t); MSG_process_create("test", test, NULL, first_host); res = MSG_main(); xbt_dynar_free(&all_hosts); XBT_INFO("Simulation time %g", MSG_get_clock()); return res; }
static void mytest(const char *input, const char *patterns, const char *expected) { xbt_dynar_t dyn_patterns; /* splited string */ xbt_dict_t p; /* patterns */ unsigned int cpt; char *str; /*foreach */ xbt_strbuff_t sb; /* what we test */ p = xbt_dict_new_homogeneous(free); dyn_patterns = xbt_str_split(patterns, " "); xbt_dynar_foreach(dyn_patterns, cpt, str) { xbt_dynar_t keyvals = xbt_str_split(str, "="); char *key = xbt_dynar_get_as(keyvals, 0, char *); char *val = xbt_dynar_get_as(keyvals, 1, char *); xbt_str_subst(key, '_', ' ', 0); // to put space in names without breaking the enclosing dynar_foreach xbt_dict_set(p, key, xbt_strdup(val), NULL); xbt_dynar_free(&keyvals); }
JNIEXPORT jobjectArray JNICALL Java_org_simgrid_msg_Host_all(JNIEnv * env, jclass cls_arg) { int index; jobjectArray jtable; jobject jhost; jstring jname; msg_host_t host; xbt_dynar_t table = MSG_hosts_as_dynar(); int count = xbt_dynar_length(table); jclass cls = jxbt_get_class(env, "org/simgrid/msg/Host"); if (!cls) { return NULL; } jtable = (*env)->NewObjectArray(env, (jsize) count, cls, NULL); if (!jtable) { jxbt_throw_jni(env, "Hosts table allocation failed"); return NULL; } for (index = 0; index < count; index++) { host = xbt_dynar_get_as(table,index,msg_host_t); jhost = (jobject) (MSG_host_get_data(host)); if (!jhost) { jname = (*env)->NewStringUTF(env, MSG_host_get_name(host)); jhost = Java_org_simgrid_msg_Host_getByName(env, cls_arg, jname); /* FIXME: leak of jname ? */ } (*env)->SetObjectArrayElement(env, jtable, index, jhost); } xbt_dynar_free(&table); return jtable; }
int main(int argc, char *argv[]) { MSG_init(&argc, argv); xbt_assert(argc > 2, "Usage: %s platform_file deployment_file\n" "\tExample: %s msg_platform.xml msg_deployment.xml\n", argv[0], argv[0]); MSG_create_environment(argv[1]); //declaring user variables TRACE_host_variable_declare("is_worker"); TRACE_host_variable_declare("is_master"); TRACE_host_variable_declare("task_creation"); TRACE_host_variable_declare("task_computation"); //declaring user markers and values TRACE_declare_mark("msmark"); TRACE_declare_mark_value ("msmark", "start_send_tasks"); TRACE_declare_mark_value ("msmark", "finish_send_tasks"); //declaring user categories with RGB colors (values from 0 to 1) TRACE_category_with_color ("compute", "1 0 0"); //compute is red TRACE_category_with_color ("finalize", "0 1 0"); //finalize is green //categories without user-defined colors receive random colors generated by the tracing system TRACE_category ("request"); TRACE_category_with_color ("report", NULL); MSG_function_register("master", master); MSG_function_register("worker", worker); MSG_launch_application(argv[2]); MSG_main(); unsigned int cursor; xbt_dynar_t categories = TRACE_get_categories (); if (categories){ XBT_INFO ("Declared tracing categories:"); char *category; xbt_dynar_foreach (categories, cursor, category){ XBT_INFO ("%s", category); } xbt_dynar_free (&categories); }
void jedule_log_sd_event(SD_task_t task) { jed_event_t event; xbt_assert(task != NULL); xbt_dynar_t host_list = xbt_dynar_new(sizeof(char*), NULL); for(int i=0; i<task->host_count; i++) { const char *hostname = sg_host_get_name(task->host_list[i]); xbt_dynar_push(host_list, &hostname); } create_jed_event(&event, (char*)SD_task_get_name(task), task->start_time, task->finish_time,"SD"); jed_event_add_resources(event, host_list); jedule_store_event(event); xbt_dynar_free(&host_list); }
static int master_main(int argc, char *argv[]) { xbt_dynar_t hosts_dynar = MSG_hosts_as_dynar(); msg_host_t pm0 = MSG_host_by_name("Fafard"); msg_vm_t vm0 = MSG_vm_create_core(pm0, "VM0"); MSG_vm_start(vm0); launch_computation_worker(vm0); while(MSG_get_clock()<100) { if (atask != NULL) XBT_INFO("aTask remaining duration: %g", MSG_task_get_flops_amount(atask)); MSG_process_sleep(1); } MSG_process_sleep(10000); MSG_vm_destroy(vm0); xbt_dynar_free(&hosts_dynar); return 1; }
int main(int argc, char **argv) { int res; xbt_dynar_t all_hosts; msg_host_t first_host; MSG_init(&argc, argv); MSG_create_environment(argv[1]); MSG_function_register("host", host); all_hosts = MSG_hosts_as_dynar(); first_host = xbt_dynar_pop_as(all_hosts,msg_host_t); MSG_process_create( "host", host, NULL, first_host); xbt_dynar_free(&all_hosts); res = MSG_main(); XBT_INFO("Simulation time %g", MSG_get_clock()); if (res == MSG_OK) return 0; else return 1; }
void xbt_multidict_remove(xbt_dict_t mdict, xbt_dynar_t keys) { xbt_dynar_t lens = xbt_dynar_new(sizeof(unsigned long int), NULL); unsigned long i; for (i = 0; i < xbt_dynar_length(keys); i++) { char *thiskey = xbt_dynar_get_as(keys, i, char *); unsigned long int thislen = strlen(thiskey); xbt_dynar_push(lens, &thislen); } TRY { xbt_multidict_remove_ext(mdict, keys, lens); } TRY_CLEANUP { xbt_dynar_free(&lens); } CATCH_ANONYMOUS { RETHROW; } }
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); }
static int receiver(int argc, char *argv[]) { xbt_assert(argc==3, "This function expects 2 parameters from the XML deployment file"); int id = xbt_str_parse_int(argv[1], "ID should be numerical, not %s"); int task_amount = xbt_str_parse_int(argv[2], "Invalid amount of tasks: %s"); msg_task_t *tasks = xbt_new(msg_task_t, task_amount); xbt_dynar_t comms = xbt_dynar_new(sizeof(msg_comm_t), NULL); char mailbox[80]; snprintf(mailbox,79, "receiver-%d", id); MSG_process_sleep(10); for (int i = 0; i < task_amount; i++) { XBT_INFO("Wait to receive task %d", i); tasks[i] = NULL; msg_comm_t comm = MSG_task_irecv(&tasks[i], mailbox); xbt_dynar_push_as(comms, msg_comm_t, comm); } /* Here we are waiting for the receiving of all communications */ while (!xbt_dynar_is_empty(comms)) { msg_comm_t comm; // MSG_comm_waitany returns the rank of the comm that just ended. Remove it. xbt_dynar_remove_at(comms, MSG_comm_waitany(comms), &comm); msg_task_t task = MSG_comm_get_task(comm); MSG_comm_destroy(comm); XBT_INFO("Processing \"%s\"", MSG_task_get_name(task)); MSG_task_execute(task); XBT_INFO("\"%s\" done", MSG_task_get_name(task)); msg_error_t err = MSG_task_destroy(task); xbt_assert(err == MSG_OK, "MSG_task_destroy failed"); } xbt_dynar_free(&comms); xbt_free(tasks); /* Here we tell to sender that all tasks are done */ MSG_task_send(MSG_task_create(NULL, 0, 0, NULL), "finalize"); XBT_INFO("I'm done. See you!"); return 0; }
static int test_parmap_basic(e_xbt_parmap_mode_t mode) { int ret = 0; unsigned num_workers; for (num_workers = 1 ; num_workers <= 16 ; num_workers *= 2) { const unsigned len = 1033; const unsigned num = 5; unsigned *a; xbt_dynar_t data; xbt_parmap_t parmap; unsigned i; parmap = xbt_parmap_new(num_workers, mode); a = xbt_malloc(len * sizeof *a); data = xbt_dynar_new(sizeof a, NULL); for (i = 0; i < len; i++) { a[i] = i; xbt_dynar_push_as(data, void *, &a[i]); } for (i = 0; i < num; i++) xbt_parmap_apply(parmap, fun_double, data); for (i = 0; i < len; i++) { unsigned expected = (1U << num) * (i + 1) - 1; if (a[i] != expected) { XBT_CRITICAL("with %u threads, a[%u]: expected %u, got %u", num_workers, i, expected, a[i]); ret = 1; break; } } xbt_dynar_free(&data); xbt_free(a); xbt_parmap_destroy(parmap); } return ret; }
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; }
JNIEXPORT jobjectArray JNICALL Java_org_simgrid_msg_Storage_all(JNIEnv * env, jclass cls_arg) { int index; jobjectArray jtable; jobject jstorage; jstring jname; msg_storage_t storage; xbt_dynar_t table = MSG_storages_as_dynar(); int count = xbt_dynar_length(table); jclass cls = jxbt_get_class(env, "org/simgrid/msg/Storage"); if (!cls) { return NULL; } jtable = (*env)->NewObjectArray(env, (jsize) count, cls, NULL); if (!jtable) { jxbt_throw_jni(env, "Storages table allocation failed"); return NULL; } for (index = 0; index < count; index++) { storage = xbt_dynar_get_as(table,index,msg_storage_t); jstorage = (jobject) (xbt_lib_get_level(storage, JAVA_STORAGE_LEVEL)); if (!jstorage) { jname = (*env)->NewStringUTF(env, MSG_storage_get_name(storage)); jstorage = Java_org_simgrid_msg_Storage_getByName(env, cls_arg, jname); } (*env)->SetObjectArrayElement(env, jtable, index, jstorage); } xbt_dynar_free(&table); return jtable; }
void Container::createHierarchy(NetZone_t from_as) { xbt_dict_cursor_t cursor = nullptr; char *key; NetZone_t elem; xbt_dict_t routing_sons = from_as->children(); if (xbt_dict_is_empty(routing_sons)) { // I am no AS // add hosts to jedule platform xbt_dynar_t table = from_as->hosts(); unsigned int dynar_cursor; sg_host_t host; std::vector<sg_host_t> hosts; xbt_dynar_foreach(table, dynar_cursor, host) { hosts.push_back(host); } this->addResources(hosts); xbt_dynar_free(&table); } else {
static int test_parmap_extended(e_xbt_parmap_mode_t mode) { int ret = 0; unsigned num_workers; for (num_workers = 1 ; num_workers <= 16 ; num_workers *= 2) { const unsigned len = 2 * num_workers; uintptr_t *a; xbt_parmap_t parmap; xbt_dynar_t data; unsigned i; unsigned count; parmap = xbt_parmap_new(num_workers, mode); a = xbt_malloc(len * sizeof *a); data = xbt_dynar_new(sizeof a, NULL); for (i = 0; i < len; i++) xbt_dynar_push_as(data, void *, &a[i]); xbt_parmap_apply(parmap, fun_get_id, data); qsort(a, len, sizeof a[0], fun_compare); count = 1; for (i = 1; i < len; i++) if (a[i] != a[i - 1]) count++; if (count != num_workers) { XBT_CRITICAL("only %u/%u threads did some work", count, num_workers); ret = 1; } xbt_dynar_free(&data); xbt_free(a); xbt_parmap_destroy(parmap); } return ret; }
int main(int argc, char **argv) { int res; MSG_init(&argc, argv); MSG_create_environment(argv[1]); xbt_dynar_t hosts = MSG_hosts_as_dynar(); MSG_function_register("host", host); unsigned long nb_hosts = xbt_dynar_length(hosts); XBT_INFO("Number of host '%lu'",nb_hosts); char* name_host = xbt_strdup("0"); MSG_process_create( name_host, host, NULL, xbt_dynar_get_as(hosts,0,msg_host_t) ); free(name_host); xbt_dynar_free(&hosts); res = MSG_main(); XBT_INFO("Simulation time %g", MSG_get_clock()); if (res == MSG_OK) return 0; else return 1; }
int main(int argc, char *argv[]) { MSG_init(&argc, argv); MSG_config("host/model", "ptask_L07"); xbt_assert(argc <= 3, "1Usage: %s <platform file> [--energy]", argv[0]); xbt_assert(argc >= 2, "2Usage: %s <platform file> [--energy]", argv[0]); if(argc == 3 && argv[2][2] == 'e') sg_energy_plugin_init(); MSG_create_environment(argv[1]); /* Pick a process, no matter which, from the platform file */ xbt_dynar_t all_hosts = MSG_hosts_as_dynar(); msg_host_t first_host = xbt_dynar_getfirst_as(all_hosts,msg_host_t); xbt_dynar_free(&all_hosts); MSG_process_create("test", runner, NULL, first_host); msg_error_t res = MSG_main(); XBT_INFO("Simulation done."); return res != MSG_OK; }
/** \brief Insert \e data under all the keys contained in \e keys * * \arg head: the head of dict * \arg keys: dynar of null-terminated strings containing all the keys * \arg data: what to store in the structure * \arg free_ctn: function to use to free the pushed content on need */ void xbt_multidict_set(xbt_dict_t mdict, xbt_dynar_t keys, void *data, void_f_pvoid_t free_ctn) { xbt_dynar_t lens = xbt_dynar_new(sizeof(unsigned long int), NULL); unsigned long i; for (i = 0; i < xbt_dynar_length(keys); i++) { char *thiskey = xbt_dynar_get_as(keys, i, char *); unsigned long int thislen = (unsigned long int) strlen(thiskey); XBT_DEBUG("Push %ld as level %lu length", thislen, i); xbt_dynar_push(lens, &thislen); } TRY { xbt_multidict_set_ext(mdict, keys, lens, data, free_ctn); } TRY_CLEANUP { xbt_dynar_free(&lens); } CATCH_ANONYMOUS { RETHROW; } }
static inline void routing_storage_host_free(void *r) { xbt_dynar_t dyn = (xbt_dynar_t) r; xbt_dynar_free(&dyn); }
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; }