/**
* Bittorrent example launcher
*/
int main(int argc, char *argv[])
{
xbt_dynar_t host_list;
msg_host_t host;
unsigned i;
MSG_init(&argc, argv);
/* Check the arguments */
if (argc < 3) {
printf("Usage: %s platform_file deployment_file \n", argv[0]);
return -1;
}
const char *platform_file = argv[1];
const char *deployment_file = argv[2];
MSG_create_environment(platform_file);
host_list = MSG_hosts_as_dynar();
xbt_dynar_foreach(host_list, i, host) {
char descr[512];
RngStream stream;
snprintf(descr, sizeof descr, "RngSream<%s>", MSG_host_get_name(host));
stream = RngStream_CreateStream(descr);
MSG_host_set_data(host, stream);
}
int main(int argc, char **argv)
{
int i,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);
for(i = 0 ; i<nb_hosts; i++)
{
char* name_host = bprintf("%d",i);
MSG_process_create( name_host, host, NULL, xbt_dynar_get_as(hosts,i,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;
}
JNIEXPORT jint JNICALL
Java_org_simgrid_msg_Host_getCount(JNIEnv * env, jclass cls) {
xbt_dynar_t hosts = MSG_hosts_as_dynar();
int nb_host = xbt_dynar_length(hosts);
xbt_dynar_free(&hosts);
return (jint) nb_host;
}
int main(int argc, char **argv)
{
int i;
msg_error_t res = MSG_OK;
MSG_init(&argc, argv);
surf_parse = surf_parse_bypass_platform;
MSG_create_environment(NULL);
MSG_function_register("host", host);
xbt_dynar_t hosts = MSG_hosts_as_dynar();
nb_hosts = xbt_dynar_length(hosts);
XBT_INFO("Number of host '%d'",nb_hosts);
for(i = 0 ; i<nb_hosts; i++)
{
char* name_host = bprintf("%d",i);
MSG_process_create( name_host, host, NULL, xbt_dynar_get_as(hosts,i,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;
}
/**
* \brief Returns the number of existing hosts.
* \param L a Lua state
* \return number of values returned to Lua
*
* - Return value (number): number of hosts
*/
static int l_host_number(lua_State * L)
{
xbt_dynar_t hosts = MSG_hosts_as_dynar();
lua_pushnumber(L, xbt_dynar_length(hosts));
xbt_dynar_free(&hosts);
return 1;
}
JNIEXPORT void JNICALL JNICALL Java_org_simgrid_msg_Msg_run(JNIEnv * env, jclass cls)
{
/* Run everything */
XBT_DEBUG("Ready to run MSG_MAIN");
msg_error_t rv = MSG_main();
XBT_DEBUG("Done running MSG_MAIN");
jxbt_check_res("MSG_main()", rv, MSG_OK,
xbt_strdup("unexpected error : MSG_main() failed .. please report this bug "));
XBT_INFO("MSG_main finished; Cleaning up the simulation...");
/* Cleanup java hosts */
xbt_dynar_t hosts = MSG_hosts_as_dynar();
for (unsigned long index = 0; index < xbt_dynar_length(hosts) - 1; index++) {
msg_host_t msg_host = xbt_dynar_get_as(hosts,index,msg_host_t);
jobject jhost = (jobject) msg_host->extension(JAVA_HOST_LEVEL);
if (jhost)
jhost_unref(env, jhost);
}
xbt_dynar_free(&hosts);
/* Cleanup java storages */
xbt_dynar_t storages = MSG_storages_as_dynar();
if(!xbt_dynar_is_empty(storages)){
for (unsigned long index = 0; index < xbt_dynar_length(storages) - 1; index++) {
jobject jstorage = (jobject) xbt_lib_get_level(xbt_dynar_get_as(storages,index,msg_storage_t), JAVA_STORAGE_LEVEL);
if (jstorage)
jstorage_unref(env, jstorage);
}
}
xbt_dynar_free(&storages);
}
/**
* Main function
* Create the platform, list the available hosts and give them some work
*/
int main(int argc, char **argv) {
unsigned long seed[] = {134, 233445, 865, 2634, 424242, 876543};
int connected;
int max_tries = 10;
//MSG initialization
MSG_init(&argc, argv);
//Set up the seed for the platform generation
platf_random_seed(seed);
XBT_INFO("creating nodes...");
platf_graph_uniform(50);
do {
max_tries--;
XBT_INFO("creating links...");
platf_graph_clear_links();
platf_graph_interconnect_uniform(0.07); //Unrealistic, but simple
XBT_INFO("done. Check connectedness...");
connected = platf_graph_is_connected();
XBT_INFO("Is it connected : %s", connected ? "yes" : (max_tries ? "no, retrying" : "no"));
} while(!connected && max_tries);
if(!connected && !max_tries) {
xbt_die("Impossible to connect the graph, aborting.");
}
XBT_INFO("registering callbacks...");
platf_graph_promoter(promoter_1);
platf_graph_labeler(labeler_1);
XBT_INFO("protmoting...");
platf_do_promote();
XBT_INFO("labeling...");
platf_do_label();
XBT_INFO("Putting it in surf...");
platf_generate();
XBT_INFO("Let's get the available hosts and dispatch work:");
unsigned int i;
msg_host_t host = NULL;
msg_host_t host_master = NULL;
xbt_dynar_t host_dynar = MSG_hosts_as_dynar();
char** hostname_list = xbt_malloc(sizeof(char*) * xbt_dynar_length(host_dynar));
xbt_dynar_foreach(host_dynar, i, host) {
MSG_process_create("slave", slave, NULL, host);
if(i==0) {
//The first node will also be the master
XBT_INFO("%s will be the master", MSG_host_get_name(host));
host_master = host;
}
hostname_list[i] = (char*) MSG_host_get_name(host);
}
static int runner(int argc, char *argv[])
{
/* Retrieve the list of all hosts as an array of hosts */
int hosts_count = MSG_get_host_number();
msg_host_t *hosts = xbt_dynar_to_array(MSG_hosts_as_dynar());
XBT_INFO("First, build a classical parallel task, with 1 Gflop to execute on each node, "
"and 10MB to exchange between each pair");
double *computation_amounts = xbt_new0(double, hosts_count);
double *communication_amounts = xbt_new0(double, hosts_count * hosts_count);
for (int i = 0; i < hosts_count; i++)
computation_amounts[i] = 1e9; // 1 Gflop
for (int i = 0; i < hosts_count; i++)
for (int j = i + 1; j < hosts_count; j++)
communication_amounts[i * hosts_count + j] = 1e7; // 10 MB
msg_task_t ptask =
MSG_parallel_task_create("parallel task", hosts_count, hosts, computation_amounts, communication_amounts, NULL);
MSG_parallel_task_execute(ptask);
MSG_task_destroy(ptask);
/* The arrays communication_amounts and computation_amounts are not to be freed manually */
XBT_INFO("Then, build a parallel task involving only computations and no communication (1 Gflop per node)");
computation_amounts = xbt_new0(double, hosts_count);
for (int i = 0; i < hosts_count; i++)
computation_amounts[i] = 1e9; // 1 Gflop
ptask = MSG_parallel_task_create("parallel exec", hosts_count, hosts, computation_amounts, NULL/* no comm */, NULL);
MSG_parallel_task_execute(ptask);
MSG_task_destroy(ptask);
XBT_INFO("Then, build a parallel task with no computation nor communication (synchro only)");
computation_amounts = xbt_new0(double, hosts_count);
communication_amounts = xbt_new0(double, hosts_count * hosts_count); /* memset to 0 by xbt_new0 */
ptask = MSG_parallel_task_create("parallel sync", hosts_count, hosts, computation_amounts, communication_amounts, NULL);
MSG_parallel_task_execute(ptask);
MSG_task_destroy(ptask);
XBT_INFO("Finally, trick the ptask to do a 'remote execution', on host %s", MSG_host_get_name(hosts[1]));
computation_amounts = xbt_new0(double, 1);
computation_amounts[0] = 1e9; // 1 Gflop
msg_host_t *remote = xbt_new(msg_host_t,1);
remote[0] = hosts[1];
ptask = MSG_parallel_task_create("remote exec", 1, remote, computation_amounts, NULL/* no comm */, NULL);
MSG_parallel_task_execute(ptask);
MSG_task_destroy(ptask);
free(remote);
XBT_INFO("Goodbye now!");
free(hosts);
return 0;
}
/** Main function */
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
long i;
MSG_init(&argc, argv);
if (argc < 4) {
printf("Usage: %s platform_file number_of_jobs number_of_slaves\n", argv[0]);
printf("example: %s msg_platform.xml 10 5\n", argv[0]);
exit(1);
}
MSG_function_register("master", master);
MSG_function_register("slave", slave);
MSG_create_environment(argv[1]);
number_of_jobs = atol(argv[2]);
number_of_slaves = atol(argv[3]);
xbt_dynar_t host_dynar = MSG_hosts_as_dynar();
long number_max = xbt_dynar_length(host_dynar);
XBT_INFO("Got %ld slaves, %ld tasks to process, and %ld hosts", number_of_slaves, number_of_jobs,number_max);
msg_host_t *host_table = xbt_dynar_to_array(host_dynar);
//xbt_dynar_free(&host_dynar);
MSG_process_create( "master",
master,
NULL,
host_table[my_random(number_max)]
);
for(i = 0 ; i<number_of_slaves; i++)
{
char* name_host = bprintf("slave-%ld",i);
MSG_process_create( name_host,
slave,
NULL,
host_table[my_random(number_max)]
);
free(name_host);
}
xbt_free(host_table);
res = MSG_main();
XBT_INFO("Simulation time %g", MSG_get_clock());
if (res == MSG_OK)
return 0;
else
return 1;
} /* end_of_main */
/**
* \brief Returns the host given its index.
* \param L a Lua state
* \return number of values returned to Lua
*
* - Argument 1 (number): an index (1 is the first)
* - Return value (host): the host at this index
*/
static int l_host_at(lua_State * L)
{
int index = luaL_checkinteger(L, 1);
xbt_dynar_t hosts = MSG_hosts_as_dynar();
msg_host_t host = xbt_dynar_get_as(hosts,index - 1,msg_host_t);// lua indexing start by 1 (lua[1] <=> C[0])
lua_newtable(L); /* create a table, put the userdata on top of it */
msg_host_t *lua_host = (msg_host_t *) lua_newuserdata(L, sizeof(msg_host_t));
*lua_host = host;
luaL_getmetatable(L, HOST_MODULE_NAME);
lua_setmetatable(L, -2);
lua_setfield(L, -2, "__simgrid_host"); /* put the userdata as field of the table */
xbt_dynar_free(&hosts);
return 1;
}
int main(int argc, char *argv[])
{
MSG_init(&argc, argv);
xbt_assert(argc>1, "Usage: %s platform.xml\n",argv[0]);
MSG_create_environment(argv[1]); /* - Load the platform description */
xbt_dynar_t hosts = MSG_hosts_as_dynar();
XBT_INFO("Number of hosts '%d'", MSG_get_host_number());
unsigned int i;
msg_host_t h;
xbt_dynar_foreach (hosts, i, h) { /* - Give a unique rank to each host and create a @ref relay_runner process on each */
char* name_host = bprintf("%u",i);
MSG_process_create(name_host, relay_runner, NULL, h);
free(name_host);
}
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);
}
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;
}
/** 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;
}
/** Bittorrent example launcher */
int main(int argc, char* argv[])
{
msg_host_t host;
unsigned i;
MSG_init(&argc, argv);
/* Check the arguments */
xbt_assert(argc > 2, "Usage: %s platform_file deployment_file", argv[0]);
MSG_create_environment(argv[1]);
xbt_dynar_t host_list = MSG_hosts_as_dynar();
xbt_dynar_foreach (host_list, i, host) {
char descr[512];
snprintf(descr, sizeof descr, "RngSream<%s>", MSG_host_get_name(host));
RngStream stream = RngStream_CreateStream(descr);
MSG_host_set_data(host, stream);
}
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;
}
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;
}
/** Emitter function */
int test(int argc, char *argv[])
{
xbt_dynar_t slaves_dynar;
int slaves_count = 0;
msg_host_t *slaves = NULL;
double task_comp_size = 100000;
double task_comm_size = 10000;
double *computation_amount = NULL;
double *communication_amount = NULL;
msg_task_t ptask = NULL;
int i, j;
slaves_dynar = MSG_hosts_as_dynar();
slaves_count = xbt_dynar_length(slaves_dynar);
slaves = xbt_dynar_to_array(slaves_dynar);
computation_amount = xbt_new0(double, slaves_count);
communication_amount = xbt_new0(double, slaves_count * slaves_count);
for (i = 0; i < slaves_count; i++)
computation_amount[i] = task_comp_size;
for (i = 0; i < slaves_count; i++)
for (j = i + 1; j < slaves_count; j++)
communication_amount[i * slaves_count + j] = task_comm_size;
ptask = MSG_parallel_task_create("parallel task",
slaves_count, slaves,
computation_amount,
communication_amount, NULL);
MSG_parallel_task_execute(ptask);
MSG_task_destroy(ptask);
/* There is no need to free that! */
/* free(communication_amount); */
/* free(computation_amount); */
XBT_INFO("Goodbye now!");
free(slaves);
return 0;
}
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;
}
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;
}
/** Emitter function */
int master(int argc, char *argv[])
{
int workers_count = 0;
msg_host_t *workers = NULL;
msg_task_t *todo = NULL;
msg_host_t host_self = MSG_host_self();
char *master_name = (char *) MSG_host_get_name(host_self);
double task_comp_size = 0;
double task_comm_size = 0;
char channel[1024];
double timeout = -1;
int i;
TRACE_category(master_name);
_XBT_GNUC_UNUSED int res = sscanf(argv[1], "%lg", &timeout);
xbt_assert(res,"Invalid argument %s\n", argv[1]);
res = sscanf(argv[2], "%lg", &task_comp_size);
xbt_assert(res, "Invalid argument %s\n", argv[2]);
res = sscanf(argv[3], "%lg", &task_comm_size);
xbt_assert(res, "Invalid argument %s\n", argv[3]);
{ /* Process organisation */
workers_count = MSG_get_host_number();
workers = xbt_dynar_to_array(MSG_hosts_as_dynar());
for (i = 0; i < workers_count; i++)
if(host_self == workers[i]) {
workers[i] = workers[workers_count-1];
workers_count--;
break;
}
for (i = 0; i < workers_count; i++)
MSG_process_create("worker", worker, master_name, workers[i]);
}
XBT_INFO("Got %d workers and will send tasks for %g seconds!",
workers_count, timeout);
for (i = 0; 1; i++) {
char sprintf_buffer[64];
msg_task_t task = NULL;
if(MSG_get_clock()>timeout) break;
sprintf(sprintf_buffer, "Task_%d", i);
task = MSG_task_create(sprintf_buffer, task_comp_size, task_comm_size,
NULL);
MSG_task_set_category(task, master_name);
build_channel_name(channel,master_name,
MSG_host_get_name(workers[i % workers_count]));
XBT_DEBUG("Sending \"%s\" to channel \"%s\"", task->name, channel);
MSG_task_send(task, channel);
XBT_DEBUG("Sent");
}
int task_num = i;
XBT_DEBUG
("All tasks have been dispatched. Let's tell everybody the computation is over.");
for (i = 0; i < workers_count; i++) {
msg_task_t finalize = MSG_task_create("finalize", 0, 0, FINALIZE);
MSG_task_send(finalize, build_channel_name(channel,master_name,
MSG_host_get_name(workers[i % workers_count])));
}
XBT_INFO("Sent %d tasks in total!", task_num);
free(workers);
free(todo);
return 0;
} /* end_of_master */
/** Emitter function */
int master(int argc, char *argv[])
{
int workers_count = 0;
msg_host_t *workers = NULL;
msg_task_t *todo = NULL;
msg_host_t host_self = MSG_host_self();
char *master_name = (char *) MSG_host_get_name(host_self);
int number_of_tasks = 0;
double task_comp_size = 0;
double task_comm_size = 0;
char channel[1024];
int i;
_XBT_GNUC_UNUSED int res = sscanf(argv[1], "%d", &number_of_tasks);
xbt_assert(res,"Invalid argument %s\n", argv[1]);
res = sscanf(argv[2], "%lg", &task_comp_size);
xbt_assert(res, "Invalid argument %s\n", argv[2]);
res = sscanf(argv[3], "%lg", &task_comm_size);
xbt_assert(res, "Invalid argument %s\n", argv[3]);
{ /* Task creation */
char sprintf_buffer[64];
todo = xbt_new0(msg_task_t, number_of_tasks);
for (i = 0; i < number_of_tasks; i++) {
sprintf(sprintf_buffer, "Task_%d", i);
todo[i] =
MSG_task_create(sprintf_buffer, task_comp_size, task_comm_size,
NULL);
}
}
{ /* Process organisation */
workers_count = MSG_get_host_number();
workers = xbt_dynar_to_array(MSG_hosts_as_dynar());
for (i = 0; i < workers_count; i++)
if(host_self == workers[i]) {
workers[i] = workers[workers_count-1];
workers_count--;
break;
}
for (i = 0; i < workers_count; i++)
MSG_process_create("worker", worker, master_name, workers[i]);
}
XBT_INFO("Got %d workers and %d tasks to process", workers_count,
number_of_tasks);
for (i = 0; i < number_of_tasks; i++) {
build_channel_name(channel,master_name,
MSG_host_get_name(workers[i % workers_count]));
XBT_INFO("Sending \"%s\" to channel \"%s\"", todo[i]->name, channel);
MSG_task_send(todo[i], channel);
XBT_INFO("Sent");
}
XBT_INFO
("All tasks have been dispatched. Let's tell everybody the computation is over.");
for (i = 0; i < workers_count; i++) {
msg_task_t finalize = MSG_task_create("finalize", 0, 0, FINALIZE);
MSG_task_send(finalize, build_channel_name(channel,master_name,
MSG_host_get_name(workers[i % workers_count])));
}
XBT_INFO("Goodbye now!");
free(workers);
free(todo);
return 0;
} /* end_of_master */
/** Bypass deployment **/
static int bypass_deployment(void)
{
int nb_host,i;
static int AX_ptr;
static int surfxml_bufferstack_size = 2048;
static int surfxml_buffer_stack_stack_ptr = 0;
static int surfxml_buffer_stack_stack[1024];
xbt_dynar_t hosts = MSG_hosts_as_dynar();
/* allocating memory to the buffer, I think 2MB should be enough */
surfxml_bufferstack = xbt_new0(char, surfxml_bufferstack_size);
nb_host = xbt_dynar_length(hosts);
xbt_dynar_free(&hosts);
/* <platform> */
SURFXML_BUFFER_SET(platform_version, "3");
SURFXML_START_TAG(platform);
XBT_DEBUG("<platform version=\"3\">");
XBT_DEBUG(" <process host=\"c-0.me\" function=\"master\">");
SURFXML_BUFFER_SET(process_host, "c-0.me");
SURFXML_BUFFER_SET(process_function, "master");
SURFXML_BUFFER_SET(process_start___time, "-1.0");
SURFXML_BUFFER_SET(process_kill___time, "-1.0");
SURFXML_START_TAG(process);
XBT_DEBUG(" <argument value=\"%s\"/>",bprintf("%d",nb_host-1));
SURFXML_BUFFER_SET(argument_value, bprintf("%d",nb_host-1));
SURFXML_START_TAG(argument);
SURFXML_END_TAG(argument);
XBT_DEBUG(" <argument value=\"5000000\"/>");
SURFXML_BUFFER_SET(argument_value, "5000000");
SURFXML_START_TAG(argument);
SURFXML_END_TAG(argument);
XBT_DEBUG(" <argument value=\"100000\"/>");
SURFXML_BUFFER_SET(argument_value, "100000");
SURFXML_START_TAG(argument);
SURFXML_END_TAG(argument);
for(i=1 ; i<nb_host ; i++)
{
XBT_DEBUG(" <argument value=\"%s.me\"/>",bprintf("c-%d",i));
SURFXML_BUFFER_SET(argument_value, bprintf("c-%d.me",i));
SURFXML_START_TAG(argument);
SURFXML_END_TAG(argument);
}
XBT_DEBUG(" </process>");
SURFXML_END_TAG(process);
for(i=1 ; i<nb_host ; i++)
{
XBT_DEBUG(" <process host=\"%s.me\" function=\"slave\"/>",bprintf("c-%d",i));
SURFXML_BUFFER_SET(process_host, bprintf("c-%d.me",i));
SURFXML_BUFFER_SET(process_function, "slave");
SURFXML_BUFFER_SET(process_start___time, "-1.0");
SURFXML_BUFFER_SET(process_kill___time, "-1.0");
SURFXML_START_TAG(process);
SURFXML_END_TAG(process);
}
XBT_DEBUG("</platform>");
SURFXML_END_TAG(platform);
free(surfxml_bufferstack);
return 0;
}
/** Emitter function */
static int master(int argc, char *argv[])
{
int workers_count = 0;
msg_host_t *workers = NULL;
msg_task_t *todo = NULL;
msg_host_t host_self = MSG_host_self();
char *master_name = (char *) MSG_host_get_name(host_self);
char channel[1024];
int i;
long number_of_tasks = xbt_str_parse_int(argv[1], "Invalid amount of tasks: %s"); /** - Number of tasks */
double comp_size = xbt_str_parse_double(argv[2], "Invalid computational size: %s"); /** - Task compute cost */
double comm_size = xbt_str_parse_double(argv[3], "Invalid communication size: %s"); /** - Task communication size */
{ /* Task creation */
char sprintf_buffer[64];
todo = xbt_new0(msg_task_t, number_of_tasks);
for (i = 0; i < number_of_tasks; i++) {
sprintf(sprintf_buffer, "Task_%d", i);
todo[i] = MSG_task_create(sprintf_buffer, task_comp_size, task_comm_size, NULL);
}
}
{ /* Process organization */
workers_count = MSG_get_host_number();
workers = xbt_dynar_to_array(MSG_hosts_as_dynar());
for (i = 0; i < workers_count; i++)
if(host_self == workers[i]) {
workers[i] = workers[workers_count-1];
workers_count--;
break;
}
for (i = 0; i < workers_count; i++)
MSG_process_create("worker", worker, master_name, workers[i]);
}
XBT_INFO("Got %d workers and %Ld tasks to process", workers_count, number_of_tasks);
for (i = 0; i < number_of_tasks; i++) {
build_channel_name(channel,master_name, MSG_host_get_name(workers[i % workers_count]));
XBT_INFO("Sending \"%s\" to channel \"%s\"", todo[i]->name, channel);
MSG_task_send(todo[i], channel);
XBT_INFO("Sent");
}
XBT_INFO ("All tasks have been dispatched. Let's tell everybody the computation is over.");
for (i = 0; i < workers_count; i++) {
msg_task_t finalize = MSG_task_create("finalize", 0, 0, FINALIZE);
MSG_task_send(finalize, build_channel_name(channel,master_name, MSG_host_get_name(workers[i % workers_count])));
}
XBT_INFO("Goodbye now!");
free(workers);
free(todo);
return 0;
} /* end_of_master */
/** Main function */
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
unsigned long seed_platf_gen[] = {134, 233445, 865, 2634, 424242, 876543};
unsigned long seed_trace_gen[] = {8865244, 356772, 42, 77465, 2098754, 8725442};
int connected;
int max_tries = 10;
//MSG initialization
MSG_init(&argc, argv);
//Set up the seed for the platform generation
platf_random_seed(seed_platf_gen);
//Set up the RngStream for trace generation
sg_platf_rng_stream_init(seed_trace_gen);
XBT_INFO("creating nodes...");
platf_graph_uniform(10);
do {
max_tries--;
XBT_INFO("creating links...");
platf_graph_clear_links();
platf_graph_interconnect_waxman(0.9, 0.4);
XBT_INFO("done. Check connectedness...");
connected = platf_graph_is_connected();
XBT_INFO("Is it connected : %s", connected ? "yes" : (max_tries ? "no, retrying" : "no"));
} while(!connected && max_tries);
if(!connected && !max_tries) {
xbt_die("Impossible to connect the graph, aborting.");
}
XBT_INFO("registering callbacks...");
platf_graph_promoter(promoter_1);
platf_graph_labeler(labeler_1);
XBT_INFO("promoting...");
platf_do_promote();
XBT_INFO("labeling...");
platf_do_label();
XBT_INFO("Putting it in surf...");
platf_generate();
XBT_INFO("Let's get the available hosts and dispatch work:");
unsigned int i;
msg_host_t host = NULL;
msg_host_t host_master = NULL;
msg_process_t process = NULL;
xbt_dynar_t host_dynar = MSG_hosts_as_dynar();
char** hostname_list =
xbt_malloc(sizeof(char*) * xbt_dynar_length(host_dynar));
xbt_dynar_foreach(host_dynar, i, host) {
process = MSG_process_create("slave", slave, NULL, host);
MSG_process_auto_restart_set(process, TRUE);
hostname_list[i] = (char*) MSG_host_get_name(host);
}
/** Emitter function */
int master(int argc, char *argv[])
{
int workers_count = 0;
msg_host_t *workers = NULL;
msg_task_t *todo = NULL;
msg_host_t host_self = MSG_host_self();
char *master_name = (char *) MSG_host_get_name(host_self);
double task_comp_size = 0;
double task_comm_size = 0;
char channel[1024];
double timeout = -1;
int i;
TRACE_category(master_name);
_XBT_GNUC_UNUSED int res = sscanf(argv[1], "%lg", &timeout);
xbt_assert(res,"Invalid argument %s\n", argv[1]);
res = sscanf(argv[2], "%lg", &task_comp_size);
xbt_assert(res, "Invalid argument %s\n", argv[2]);
res = sscanf(argv[3], "%lg", &task_comm_size);
xbt_assert(res, "Invalid argument %s\n", argv[3]);
{ /* Process organisation */
workers_count = MSG_get_host_number();
workers = xbt_dynar_to_array(MSG_hosts_as_dynar());
for (i = 0; i < workers_count; i++)
if(host_self == workers[i]) {
workers[i] = workers[workers_count-1];
workers_count--;
break;
}
for (i = 0; i < workers_count; i++)
MSG_process_create("worker", worker, master_name, workers[i]);
}
XBT_INFO("Got %d workers and will send tasks for %g seconds!",
workers_count, timeout);
xbt_dynar_t idle_hosts = xbt_dynar_new(sizeof(msg_host_t), NULL);
msg_host_t request_host = NULL;
for (i = 0; 1;) {
char sprintf_buffer[64];
msg_task_t task = NULL;
msg_task_t request = NULL;
while(MSG_task_listen(master_name)) {
res = MSG_task_receive(&(request),master_name);
xbt_assert(res == MSG_OK, "MSG_task_receive failed");
request_host = MSG_task_get_data(request);
xbt_dynar_push(idle_hosts, &request_host);
MSG_task_destroy(request);
request = NULL;
}
if(MSG_get_clock()>timeout) {
if(xbt_dynar_length(idle_hosts) == workers_count) break;
else {
MSG_process_sleep(.1);
continue;
}
}
if(xbt_dynar_length(idle_hosts)<=0) {
/* No request. Let's wait... */
MSG_process_sleep(.1);
continue;
}
sprintf(sprintf_buffer, "Task_%d", i);
task = MSG_task_create(sprintf_buffer, task_comp_size, task_comm_size,
NULL);
MSG_task_set_category(task, master_name);
xbt_dynar_shift(idle_hosts, &request_host);
build_channel_name(channel,master_name, MSG_host_get_name(request_host));
XBT_DEBUG("Sending \"%s\" to channel \"%s\"", task->name, channel);
MSG_task_send(task, channel);
XBT_DEBUG("Sent");
i++;
}
int task_num = i;
XBT_DEBUG
("All tasks have been dispatched. Let's tell everybody the computation is over.");
for (i = 0; i < workers_count; i++) {
msg_task_t finalize = MSG_task_create("finalize", 0, 0, FINALIZE);
MSG_task_send(finalize, build_channel_name(channel,master_name,
MSG_host_get_name(workers[i % workers_count])));
}
XBT_INFO("Sent %d tasks in total!", task_num);
free(workers);
free(todo);
return 0;
} /* end_of_master */