static msg_error_t test_all(const char *platform_file,
const char *application_file)
{
msg_error_t res = MSG_OK;
{ /* Simulation setting */
MSG_create_environment(platform_file);
}
{ /* Application deployment */
MSG_function_register("test", test);
MSG_launch_application(application_file);
}
res = MSG_main();
XBT_INFO("Simulation time %g", MSG_get_clock());
return res;
}
int server(int argc, char *argv[])
{
msg_task_t task = NULL;
int count = 0;
while (count < N) {
if (task) {
MSG_task_destroy(task);
task = NULL;
}
MSG_task_receive(&task, "mymailbox");
count++;
}
MC_assert(atoi(MSG_task_get_name(task)) == 3);
XBT_INFO("OK");
return 0;
}
static int server(int argc, char *argv[])
{
msg_task_t task = NULL;
int count = 0;
while (count < N) {
if (task) {
MSG_task_destroy(task);
task = NULL;
}
MSG_task_receive(&task, "mymailbox");
count++;
}
MC_assert(xbt_str_parse_int(MSG_task_get_name(task), "Task names must be integers, not '%s'") == 3);
XBT_INFO("OK");
return 0;
}
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]);
MSG_function_register("test", test);
MSG_launch_application(argv[2]);
msg_error_t 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 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;
}
static void master()
{
int result = 0;
simgrid::s4u::MutexPtr mutex = simgrid::s4u::Mutex::create();
for (int i = 0; i < NB_ACTOR * 2 ; i++) {
// To create a worker use the static method simgrid::s4u::Actor.
if((i % 2) == 0 )
simgrid::s4u::Actor::create("worker", simgrid::s4u::Host::by_name("Jupiter"), workerLockGuard, mutex,
std::ref(result));
else
simgrid::s4u::Actor::create("worker", simgrid::s4u::Host::by_name("Tremblay"), worker, mutex, std::ref(result));
}
simgrid::s4u::this_actor::sleep_for(10);
XBT_INFO("Results is -> %d", result);
}
static void simread(const char *const *action) {
const char *processid = action[0];
const char *file_name = action[2];
const char *index = action[4];
const char *position_str =action[5];
const char *size_str = action[6];
msg_file_t file = NULL;
sg_size_t size = parse_size(size_str);
sg_offset_t position= parse_offset(position_str);
double clock = MSG_get_clock(); /* this "call" is free thanks to inlining */
file = get_file_descriptor(file_name,index);
ACT_DEBUG("Entering Read: %s (size: %llu)", NAME, size);
MSG_file_seek(file,position,SEEK_SET);
MSG_file_read(file, size);
log_action(action, MSG_get_clock() - clock);
XBT_INFO("read worker %s%s is done",processid,index);
}
int server_convert_a2i_cb(gras_msg_cb_ctx_t ctx, void *payload)
{
char *string = *(char **) payload;
long result;
char *p;
XBT_INFO("Convert %s to long", string);
result = strtol(string, &p, 10);
if (*p != '\0')
THROWF(arg_error, 0,
"Error while converting %s: this does not seem to be a valid number (problem at '%s')",
string, p);
gras_msg_rpcreturn(60, ctx, &result);
return 0;
} /* end_of_convert_callback */
int main(int argc, char* argv[])
{
MSG_init(&argc, argv);
xbt_assert(argc == 2, "Usage: %s platform_file\n\tExample: %s msg_platform.xml\n", argv[0], argv[0]);
MSG_create_environment(argv[1]);
MSG_process_create("dvfs_test", dvfs, NULL, MSG_get_host_by_name("MyHost1"));
MSG_process_create("dvfs_test", dvfs, NULL, MSG_get_host_by_name("MyHost2"));
msg_error_t res = MSG_main();
XBT_INFO("Total simulation time: %e", MSG_get_clock());
return res != MSG_OK;
}
void LivenessChecker::showAcceptanceCycle(std::size_t depth)
{
XBT_INFO("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
XBT_INFO("| ACCEPTANCE CYCLE |");
XBT_INFO("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
XBT_INFO("Counter-example that violates formula :");
simgrid::mc::dumpRecordPath();
for (auto& s : this->getTextualTrace())
XBT_INFO("%s", s.c_str());
simgrid::mc::session->logState();
XBT_INFO("Counter-example depth : %zd", depth);
}
static int master(int argc, char *argv[])
{
double task_comp_size = 5E7;
double task_comm_size = 1E6;
double timeout = 1;
const char * mailbox = "jupi";
msg_task_t task = MSG_task_create("normal", task_comp_size, task_comm_size, NULL);
XBT_INFO("Sending task: \"%s\"", task->name);
MSG_task_send_with_timeout(task, mailbox, timeout);
task = MSG_task_create("cancel directly", task_comp_size, task_comm_size, NULL);
XBT_INFO("Canceling task \"%s\" directly", task->name);
MSG_task_cancel(task);
MSG_task_destroy(task);
task = MSG_task_create("destroy directly", task_comp_size, task_comm_size, NULL);
XBT_INFO("Destroying task \"%s\" directly", task->name);
MSG_task_destroy(task);
task = MSG_task_create("cancel", task_comp_size, task_comm_size, NULL);
msg_comm_t comm = MSG_task_isend(task, mailbox);
XBT_INFO("Canceling task \"%s\" during comm", task->name);
MSG_task_cancel(task);
try {
MSG_comm_wait(comm, -1);
}
catch (xbt_ex& ex) {;
MSG_comm_destroy(comm);
}
MSG_task_destroy(task);
task = MSG_task_create("finalize", task_comp_size, task_comm_size, NULL);
comm = MSG_task_isend(task, mailbox);
XBT_INFO("Destroying task \"%s\" during comm", task->name);
MSG_task_destroy(task);
try {
MSG_comm_wait(comm, -1);
}
catch (xbt_ex& ex) {;
MSG_comm_destroy(comm);
}
task = MSG_task_create("cancel", task_comp_size, task_comm_size, NULL);
MSG_task_send_with_timeout(task, mailbox, timeout);
task = MSG_task_create("finalize", task_comp_size, task_comm_size, NULL);
MSG_task_send_with_timeout(task, mailbox, timeout);
XBT_INFO("Goodbye now!");
return 0;
}
/** Receiver function */
int receiver(int argc, char *argv[])
{
double time, time1, sender_time;
msg_task_t task_la = NULL;
msg_task_t task_bw = NULL;
int a;
double communication_time = 0;
XBT_INFO("receiver");
time = MSG_get_clock();
/* Get Latency */
a = MSG_task_receive(&task_la,MSG_host_get_name(MSG_host_self()));
if (a == MSG_OK) {
time1 = MSG_get_clock();
sender_time = *((double *) (task_la->data));
time = sender_time;
communication_time = time1 - time;
XBT_INFO("Task received : %s", task_la->name);
xbt_free(task_la->data);
MSG_task_destroy(task_la);
XBT_INFO("Communic. time %le", communication_time);
XBT_INFO("--- la %f ----", communication_time);
} else {
xbt_die("Unexpected behavior");
}
/* Get Bandwidth */
a = MSG_task_receive(&task_bw,MSG_host_get_name(MSG_host_self()));
if (a == MSG_OK) {
time1 = MSG_get_clock();
sender_time = *((double *) (task_bw->data));
time = sender_time;
communication_time = time1 - time;
XBT_INFO("Task received : %s", task_bw->name);
xbt_free(task_bw->data);
MSG_task_destroy(task_bw);
XBT_INFO("Communic. time %le", communication_time);
XBT_INFO("--- bw %f ----", task_comm_size_bw / communication_time);
} else {
xbt_die("Unexpected behavior");
}
return 0;
} /* end_of_receiver */
VMHL13::VMHL13(VMModelPtr model, const char* name, xbt_dict_t props,
surf_resource_t host_PM)
: VM(model, name, props, NULL, NULL)
{
HostPtr sub_ws = static_cast<HostPtr>(surf_host_resource_priv(host_PM));
/* Currently, we assume a VM has no storage. */
p_storage = NULL;
/* Currently, a VM uses the network resource of its physical host. In
* host_lib, this network resource object is referred from two different keys.
* When deregistering the reference that points the network resource object
* from the VM name, we have to make sure that the system does not call the
* free callback for the network resource object. The network resource object
* is still used by the physical machine. */
p_netElm = new RoutingEdgeWrapper(static_cast<RoutingEdgePtr>(xbt_lib_get_or_null(host_lib, sub_ws->getName(), ROUTING_HOST_LEVEL)));
xbt_lib_set(host_lib, name, ROUTING_HOST_LEVEL, p_netElm);
p_subWs = sub_ws;
p_currentState = SURF_VM_STATE_CREATED;
// //// CPU RELATED STUFF ////
// Roughly, create a vcpu resource by using the values of the sub_cpu one.
CpuCas01Ptr sub_cpu = static_cast<CpuCas01Ptr>(surf_cpu_resource_priv(host_PM));
/* We can assume one core and cas01 cpu for the first step.
* Do xbt_lib_set(host_lib, name, SURF_CPU_LEVEL, cpu) if you get the resource. */
p_cpu = surf_cpu_model_vm->createCpu(name, // name
sub_cpu->getPowerPeakList(), // host->power_peak,
sub_cpu->getPState(),
1, // host->power_scale,
NULL, // host->power_trace,
1, // host->core_amount,
SURF_RESOURCE_ON, // host->initial_state,
NULL, // host->state_trace,
NULL); // host->properties,
/* We create cpu_action corresponding to a VM process on the host operating system. */
/* FIXME: TODO: we have to periodically input GUESTOS_NOISE to the system? how ? */
// vm_ws->cpu_action = surf_cpu_model_pm->extension.cpu.execute(host_PM, GUESTOS_NOISE);
p_action = sub_cpu->execute(0);
XBT_INFO("Create VM(%s)@PM(%s) with %ld mounted disks", name, sub_ws->getName(), xbt_dynar_length(p_storage));
}
static void rctx_armageddon_kill_one(rctx_t initiator, const char *filepos,
rctx_t rctx)
{
if (rctx != initiator) {
XBT_INFO("Kill <%s> because <%s> failed", rctx->filepos, filepos);
xbt_os_mutex_acquire(rctx->interruption);
if (!rctx->reader_done) {
rctx->interrupted = 1;
kill(rctx->pid, SIGTERM);
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9;
nanosleep (&ts, NULL);
kill(rctx->pid, SIGKILL);
}
xbt_os_mutex_release(rctx->interruption);
}
}
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
sg_energy_plugin_init();
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]);
MSG_process_create("dvfs",dvfs,NULL,MSG_host_by_name("MyHost1"));
res = MSG_main();
XBT_INFO("Total simulation time: %.2f; All hosts must have the exact same energy consumption.", MSG_get_clock());
return res != MSG_OK;
}
int main(int argc, char *argv[])
{
msg_error_t res;
MSG_init(&argc, argv);
xbt_assert(argc == 2, "Usage: %s platform_file\n\tExample: %s msg_platform.xml\n", argv[0], argv[0]);
MSG_create_environment(argv[1]);
MSG_process_create("master", master, NULL, MSG_get_host_by_name("Tremblay"));
MSG_process_create("slave", slave, NULL, MSG_get_host_by_name("Jupiter"));
res = MSG_main();
XBT_INFO("Simulation time %g", MSG_get_clock());
return res != MSG_OK;
}
int main(int argc, char **argv)
{
int res;
unsigned int cur;
xbt_dynar_t storages;
msg_storage_t st;
MSG_init(&argc, argv);
MSG_create_environment(argv[1]);
MSG_function_register("host", host);
MSG_launch_application(argv[2]);
storages = MSG_storages_as_dynar();
xbt_dynar_foreach(storages, cur, st){
XBT_INFO("Init: %llu MiB used on '%s'",
MSG_storage_get_used_size(st)/INMEGA,
MSG_storage_get_name(st));
}
static void simopen(const char *const *action) {
const char *processid = action[0];
const char *file_name = action[2];
const char *worktime = action[3];
double sleeptime;
const char *index = action[4];
char full_name[1024];
msg_file_t file = NULL;
double clock = MSG_get_clock(); /* this "call" is free thanks to inlining */
sleeptime = atof(worktime);
MSG_process_sleep(sleeptime);
sprintf(full_name, "%s:%s:%s", file_name,MSG_process_get_name(MSG_process_self()),index);
ACT_DEBUG("Entering Open: %s (filename: %s)", NAME, file_name);
file = MSG_file_open(file_name, NULL);
xbt_dict_set(opened_files, full_name, file, NULL);
log_action(action, MSG_get_clock() - clock);
XBT_INFO("open worker %s%s is done",processid,index);
}
int main(int argc, char *argv[])
{
/* Get the arguments */
MSG_init(&argc, argv);
/* load the platform file */
xbt_assert(argc == 2, "Usage: %s platform_file\n\tExample: %s ../platforms/small_platform.xml\n", argv[0], argv[0]);
MSG_create_environment(argv[1]);
msg_host_t pm0 = MSG_host_by_name("Fafard");
launch_master(pm0);
int res = MSG_main();
XBT_INFO("Bye (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;
}
void run_service_cordel(int list_methods_len,chor_method_data list_methods[],char mailbox[]){
m_task_t received_task = NULL;
MSG_error_t res = MSG_OK;
msg_comm_t msg_recv = NULL;
static int id_sender = 0;
char sender_name[50];
sprintf(sender_name,"%s_%d",mailbox,id_sender++);
int waiting_count = 0;
while(1){
msg_recv = MSG_task_irecv(&(received_task),mailbox);
res = MSG_comm_wait(msg_recv,-1);
if(res == MSG_OK){
char task_name[100];
strcpy(task_name,MSG_task_get_name(received_task));
task_data *received_task_data = (task_data *) received_task->data;
XBT_INFO("received task %lf",received_task_data->id);
// double endtime = MSG_get_clock();
// write_log(received_task_data->starttime,endtime,"waiting time");
//received_task_data->starttime = endtime;
int index_method = find_method(list_methods_len,list_methods,task_name);
chor_method_data method_data = list_methods[index_method];
int i;
for(i = 0;i<method_data.instructions_len;i++){
method_instruction instruction = method_data.instructions[i];
if(instruction.type == INVOKE){
service_invoke(instruction.role,instruction.method_name,instruction.input_size,sender_name);
waiting_count++;
}else if(instruction.type == INVOKE_A){
service_invoke_cordel(instruction.role,instruction.method_name,instruction.input_size,received_task_data);
}else if(instruction.type == EXEC){
run_chor_task(task_name,method_data);
}
else if(instruction.type == WAIT){
wait_task(sender_name,waiting_count);
waiting_count = 0;
}
else if(instruction.type == RETURN){
return_task(task_name,received_task,method_data.output_size);
}
}
}
received_task = NULL;
}
}
/**
* \brief Main function.
*/
int main(int argc, char *argv[])
{
MSG_init(&argc, argv);
xbt_assert(argc > 2,
"Usage: %s [-nb_bits=n] [-timeout=t] platform_file deployment_file\n"
"\tExample: %s ../msg_platform.xml pastry10.xml\n",
argv[0], argv[0]);
char **options = &argv[1];
while (!strncmp(options[0], "-", 1)) {
int length = strlen("-nb_bits=");
if (!strncmp(options[0], "-nb_bits=", length) && strlen(options[0]) > length) {
nb_bits = xbt_str_parse_int(options[0] + length, "Invalid nb_bits parameter: %s");
XBT_DEBUG("Set nb_bits to %d", nb_bits);
}
else {
length = strlen("-timeout=");
if (!strncmp(options[0], "-timeout=", length) && strlen(options[0]) > length) {
timeout = xbt_str_parse_int(options[0] + length, "Invalid timeout parameter: %s");
XBT_DEBUG("Set timeout to %d", timeout);
}
else {
xbt_die("Invalid chord option '%s'", options[0]);
}
}
options++;
}
const char* platform_file = options[0];
const char* application_file = options[1];
MSG_create_environment(platform_file);
MSG_function_register("node", node);
MSG_launch_application(application_file);
msg_error_t res = MSG_main();
XBT_CRITICAL("Messages created: %ld", smx_total_comms);
XBT_INFO("Simulated time: %g", MSG_get_clock());
return res != MSG_OK;
}
/** The Lazy guy only wants to sleep, but can be awaken by the @ref dream_master. */
static int lazy_guy(int argc, char *argv[])
{
XBT_INFO("Nobody's watching me ? Let's go to sleep.");
MSG_process_suspend(MSG_process_self()); /** - Start by suspending itself */
XBT_INFO("Uuuh ? Did somebody call me ?");
XBT_INFO("Going to sleep..."); /** - Then repetitively go to sleep, but got awaken */
SLEEP(10.0);
XBT_INFO("Mmm... waking up.");
XBT_INFO("Going to sleep one more time...");
SLEEP(10.0);
XBT_INFO("Waking up once for all!");
XBT_INFO("Mmmh, goodbye now.");
return 0;
}
static int get_progress(int /*argc*/, char* /*argv*/ [])
{
while (tasks.empty()) {
MSG_process_sleep(0.5);
}
double progress;
for(auto const& task: tasks) {
double progress_prev = 1;
for (int i = 0; i < 3; i++) {
MSG_process_sleep(0.2);
progress = MSG_task_get_remaining_work_ratio(task);
xbt_assert(progress >= 0 and progress < 1, "Progress should be in [0, 1[, and not %f", progress);
xbt_assert(progress < progress_prev, "Progress should decrease, not increase");
XBT_INFO("Progress of \"%s\": %f", task->name, progress);
progress_prev = progress;
}
}
return 0;
}
int main(int argc, char *argv[])
{
MSG_init(&argc, argv);
xbt_assert(argc > 2, "Usage: %s platform_file deployment_file\n"
"\tExample: %s ../../platform/small_platform.xml app-pingpong_d.xml\n", argv[0], argv[0]);
MSG_create_environment(argv[1]); /* - Load the platform description */
MSG_function_register("pinger", pinger); /* - Register the functions to be executed by the processes */
MSG_function_register("ponger", ponger);
MSG_launch_application(argv[2]); /* - Deploy the application */
msg_error_t res = MSG_main(); /* - Run the simulation */
XBT_INFO("Total simulation time: %e", MSG_get_clock());
return res!=MSG_OK;
}
/** Main function */
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
#ifdef _MSC_VER
unsigned int prev_exponent_format =
_set_output_format(_TWO_DIGIT_EXPONENT);
#endif
MSG_init(&argc, argv);
if (argc != 3) {
XBT_CRITICAL("Usage: %s platform_file deployment_file <model>\n",
argv[0]);
XBT_CRITICAL
("example: %s msg_platform.xml msg_deployment.xml KCCFLN05_Vegas\n",
argv[0]);
exit(1);
}
/* Options for the workstation/model:
KCCFLN05 => for maxmin
KCCFLN05_proportional => for proportional (Vegas)
KCCFLN05_Vegas => for TCP Vegas
KCCFLN05_Reno => for TCP Reno
*/
//MSG_config("workstation/model", argv[3]);
res = test_all(argv[1], argv[2]);
XBT_INFO("Total simulation time: %le", MSG_get_clock());
#ifdef _MSC_VER
_set_output_format(prev_exponent_format);
#endif
if (res == MSG_OK)
return 0;
else
return 1;
} /* end_of_main */
int main(int argc, char* argv[])
{
sg_host_energy_plugin_init();
simgrid::s4u::Engine e(&argc, argv);
xbt_assert(argc > 1, "Usage: %s platform_file\n\tExample: %s msg_platform.xml\n", argv[0], argv[0]);
e.load_platform(argv[1]);
simgrid::s4u::Actor::create("dvfs", simgrid::s4u::Host::by_name("MyHost1"), dvfs);
e.run();
XBT_INFO("Total simulation time: %.2f; Host2 and Host3 must have the exact same energy consumption; Host1 is "
"multi-core and will differ.",
simgrid::s4u::Engine::get_clock());
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;
}
/** Test function */
msg_error_t test_all(const char *platform_file,
const char *application_file)
{
msg_error_t res = MSG_OK;
/* MSG_config("workstation/model","KCCFLN05"); */
{ /* Simulation setting */
MSG_create_environment(platform_file);
}
{ /* Application deployment */
MSG_function_register("sender", sender);
MSG_function_register("receiver", receiver);
MSG_launch_application(application_file);
}
res = MSG_main();
XBT_INFO("Simulation time %g", MSG_get_clock());
return res;
} /* end_of_test_all */
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
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]);/* - Load the platform description */
MSG_function_register("sender", sender);
MSG_function_register("receiver", receiver);
MSG_launch_application(argv[2]);/* - Deploy the sender and receiver processes */
res = MSG_main(); /* - Run the simulation */
XBT_INFO("Simulation time %g", MSG_get_clock());
return res != MSG_OK;
}
