/** Emitter function */
int master(int argc, char *argv[])
{
double task_comp_size = 5E7;
double task_comm_size = 1E6;
char mailbox[256];
msg_task_t task = NULL;
msg_host_t jupiter = MSG_get_host_by_name("Jupiter");
sprintf(mailbox, "jupi");
task = MSG_task_create("task on", task_comp_size, task_comm_size, NULL);
XBT_INFO("Sending \"%s\"", task->name);
if (MSG_task_send_with_timeout(task, mailbox, 1) != MSG_OK)
MSG_task_destroy(task);
MSG_process_sleep(1);
MSG_host_off(jupiter);
task = MSG_task_create("task off", task_comp_size, task_comm_size, NULL);
XBT_INFO("Sending \"%s\"", task->name);
if (MSG_task_send_with_timeout(task, mailbox, 1) != MSG_OK)
MSG_task_destroy(task);
MSG_host_on(jupiter);
xbt_swag_t jupi_processes = MSG_host_get_process_list(jupiter);
void *process;
xbt_swag_foreach(process, jupi_processes) {
MSG_process_kill(process);
}
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;
}
/*
* Join the ring
*/
static int join(node_t node){
task_data_t req_data = xbt_new0(s_task_data_t,1);
req_data->type = TASK_JOIN;
req_data->sender_id = node->id;
req_data->answer_id = node->id;
req_data->steps = 0;
get_mailbox(node->id, req_data->answer_to);
char mailbox[MAILBOX_NAME_SIZE];
get_mailbox(node->known_id, mailbox);
msg_task_t task_sent = MSG_task_create(NULL, COMP_SIZE, COMM_SIZE, req_data);
XBT_DEBUG("Trying to join Pastry ring... (with node %s)", mailbox);
MSG_task_send_with_timeout(task_sent, mailbox, timeout);
return 1;
}
/*
* Handle a given task
*/
static void handle_task(node_t node, msg_task_t task) {
XBT_DEBUG("Handling task %p", task);
char mailbox[MAILBOX_NAME_SIZE];
int i, j, min, max, d;
msg_task_t task_sent;
task_data_t req_data;
task_data_t task_data = (task_data_t) MSG_task_get_data(task);
e_task_type_t type = task_data->type;
// If the node is not ready keep the task for later
if (node->ready != 0 && !(type==TASK_JOIN_LAST_REPLY || type==TASK_JOIN_REPLY)) {
XBT_DEBUG("Task pending %i", type);
xbt_fifo_push(node->pending_tasks, task);
return;
}
switch (type) {
/*
* Try to join the ring
*/
case TASK_JOIN: {
int next = routing_next(node, task_data->answer_id);
XBT_DEBUG("Join request from %08x forwarding to %08x", task_data->answer_id, next);
type = TASK_JOIN_LAST_REPLY;
req_data = xbt_new0(s_task_data_t,1);
req_data->answer_id = task_data->sender_id;
req_data->steps = task_data->steps + 1;
// if next different from current node forward the join
if (next!=node->id) {
get_mailbox(next, mailbox);
task_data->sender_id = node->id;
task_data->steps++;
task_sent = MSG_task_create(NULL, COMP_SIZE, COMM_SIZE, task_data);
MSG_task_send_with_timeout(task_sent, mailbox, timeout);
type = TASK_JOIN_REPLY;
}
// send back the current node state to the joining node
req_data->type = type;
req_data->sender_id = node->id;
get_mailbox(node->id, req_data->answer_to);
req_data->state = node_get_state(node);
task_sent = MSG_task_create(NULL, COMP_SIZE, COMM_SIZE, req_data);
MSG_task_send_with_timeout(task_sent, task_data->answer_to, timeout);
break;
}
/*
* Join reply from all the node touched by the join
*/
case TASK_JOIN_LAST_REPLY:
// if last node touched reply, copy its namespace set
// TODO: it's work only if the two nodes are side to side (is it really the case ?)
j = (task_data->sender_id < node->id) ? -1 : 0;
for (i=0; i<NAMESPACE_SIZE/2; i++) {
node->namespace_set[i] = task_data->state->namespace_set[i-j];
node->namespace_set[NAMESPACE_SIZE-1-i] = task_data->state->namespace_set[NAMESPACE_SIZE-1-i-j-1];
}
node->namespace_set[NAMESPACE_SIZE/2+j] = task_data->sender_id;
node->ready += task_data->steps + 1;
case TASK_JOIN_REPLY:
XBT_DEBUG("Joining Reply");
// if first node touched reply, copy its neighborood set
if (task_data->sender_id == node->known_id) {
node->neighborhood_set[0] = task_data->sender_id;
for (i=1; i<NEIGHBORHOOD_SIZE; i++)
node->neighborhood_set[i] = task_data->state->neighborhood_set[i-1];
}
// copy the corresponding routing table levels
min = (node->id==task_data->answer_id) ? 0 : shl(node->id, task_data->answer_id);
max = shl(node->id, task_data->sender_id)+1;
for (i=min;i<max;i++) {
d = domain(node->id, i);
for (j=0; j<LEVEL_SIZE; j++)
if (d!=j)
node->routing_table[i][j] = task_data->state->routing_table[i][j];
}
node->ready--;
// if the node is ready, do all the pending tasks and send update to known nodes
if (node->ready==0) {
XBT_DEBUG("Node %i is ready!!!", node->id);
while(xbt_fifo_size(node->pending_tasks))
handle_task(node, xbt_fifo_pop(node->pending_tasks));
for (i=0; i<NAMESPACE_SIZE; i++) {
j = node->namespace_set[i];
if (j!=-1) {
XBT_DEBUG("Send update to %i", j);
get_mailbox(j, mailbox);
req_data = xbt_new0(s_task_data_t,1);
req_data->answer_id = node->id;
req_data->steps = 0;
req_data->type = TASK_UPDATE;
req_data->sender_id = node->id;
get_mailbox(node->id, req_data->answer_to);
req_data->state = node_get_state(node);
task_sent = MSG_task_create(NULL, COMP_SIZE, COMM_SIZE, req_data);
MSG_task_send_with_timeout(task_sent, mailbox, timeout);
}
}
}
break;
/*
* Recieved an update of state
*/
case TASK_UPDATE:
XBT_DEBUG("Task update %i !!!", node->id);
/* Update namespace ses */
printf("Task update from %i !!!\n", task_data->sender_id);
print_node_id(node);
print_node_namespace_set(node);
int curr_namespace_set[NAMESPACE_SIZE];
int task_namespace_set[NAMESPACE_SIZE+1];
// Copy the current namedspace
// and the task state namespace with state->id in the middle
i=0;
for (; i<NAMESPACE_SIZE/2; i++){
curr_namespace_set[i] = node->namespace_set[i];
task_namespace_set[i] = task_data->state->namespace_set[i];
}
task_namespace_set[i] = task_data->state->id;
for (; i<NAMESPACE_SIZE; i++){
curr_namespace_set[i] = node->namespace_set[i];
task_namespace_set[i+1] = task_data->state->namespace_set[i];
}
// get the index of values before and after node->id in task_namespace
min = -1;
max = -1;
for (i=0; i<=NAMESPACE_SIZE; i++) {
j = task_namespace_set[i];
if (i<NAMESPACE_SIZE)
printf("%08x %08x | ", j, curr_namespace_set[i]);
if (j != -1 && j < node->id) min = i;
if (j != -1 && max == -1 && j > node->id) max = i;
}
printf("\n");
// add lower elements
j = NAMESPACE_SIZE/2-1;
for (i=NAMESPACE_SIZE/2-1; i>=0; i--) {
printf("i:%i, j:%i, min:%i, currj:%08x, taskmin:%08x\n", i, j, min, curr_namespace_set[j], task_namespace_set[min]);
if (min<0) {
node->namespace_set[i] = curr_namespace_set[j];
j--;
} else if (curr_namespace_set[j] == task_namespace_set[min]) {
node->namespace_set[i] = curr_namespace_set[j];
j--; min--;
} else if (curr_namespace_set[j] > task_namespace_set[min]) {
node->namespace_set[i] = curr_namespace_set[j];
j--;
} else {
node->namespace_set[i] = task_namespace_set[min];
min--;
}
}
// add greater elements
j = NAMESPACE_SIZE/2;
for (i=NAMESPACE_SIZE/2; i<NAMESPACE_SIZE; i++) {
printf("i:%i, j:%i, max:%i, currj:%08x, taskmax:%08x\n", i, j, max, curr_namespace_set[j], task_namespace_set[max]);
if (min<0 || max>=NAMESPACE_SIZE) {
node->namespace_set[i] = curr_namespace_set[j];
j++;
} else if (curr_namespace_set[j] == -1) {
node->namespace_set[i] = task_namespace_set[max];
max++;
} else if (curr_namespace_set[j] == task_namespace_set[max]) {
node->namespace_set[i] = curr_namespace_set[j];
j++; max++;
} else if (curr_namespace_set[j] < task_namespace_set[max]) {
node->namespace_set[i] = curr_namespace_set[j];
j++;
} else {
node->namespace_set[i] = task_namespace_set[max];
max++;
}
}
print_node_namespace_set(node);
/* Update routing table */
for (i=shl(node->id, task_data->state->id); i<LEVELS_COUNT; i++) {
for (j=0; j<LEVEL_SIZE; j++) {
if (node->routing_table[i][j]==-1 && task_data->state->routing_table[i][j]==-1)
node->routing_table[i][j] = task_data->state->routing_table[i][j];
}
}
}
}
static int master(int argc, char *argv[])
{
int i;
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 workers_count = xbt_str_parse_int(argv[4], "Invalid amount of workers: %s");
XBT_INFO("Got %ld workers and %ld tasks to process", workers_count, number_of_tasks);
for (i = 0; i < number_of_tasks; i++) {
char mailbox[256];
snprintf(mailbox, 255, "worker-%ld", i % workers_count);
msg_task_t task = MSG_task_create("Task", task_comp_size, task_comm_size, xbt_new0(double, 1));
*((double *) task->data) = MSG_get_clock();
switch ( MSG_task_send_with_timeout(task,mailbox,10.0) ) {
case MSG_OK:
XBT_INFO("Send completed");
break;
case MSG_HOST_FAILURE:
XBT_INFO("Gloups. The cpu on which I'm running just turned off!. See you!");
free(task->data);
MSG_task_destroy(task);
return 0;
case MSG_TRANSFER_FAILURE:
XBT_INFO("Mmh. Something went wrong with '%s'. Nevermind. Let's keep going!", mailbox);
free(task->data);
MSG_task_destroy(task);
break;
case MSG_TIMEOUT:
XBT_INFO ("Mmh. Got timeouted while speaking to '%s'. Nevermind. Let's keep going!", mailbox);
free(task->data);
MSG_task_destroy(task);
break;
default:
xbt_die( "Unexpected behavior");
}
}
XBT_INFO("All tasks have been dispatched. Let's tell everybody the computation is over.");
for (i = 0; i < workers_count; i++) {
char mailbox[256];
snprintf(mailbox, 255, "worker-%ld", i % workers_count);
msg_task_t task = MSG_task_create("finalize", 0, 0, FINALIZE);
switch (MSG_task_send_with_timeout(task,mailbox,1.0)) {
case MSG_HOST_FAILURE:
XBT_INFO("Gloups. The cpu on which I'm running just turned off!. See you!");
MSG_task_destroy(task);
break;
case MSG_TRANSFER_FAILURE:
XBT_INFO("Mmh. Can't reach '%s'! Nevermind. Let's keep going!", mailbox);
MSG_task_destroy(task);
break;
case MSG_TIMEOUT:
XBT_INFO("Mmh. Got timeouted while speaking to '%s'. Nevermind. Let's keep going!", mailbox);
MSG_task_destroy(task);
break;
case MSG_OK:
/* nothing */
break;
default:
xbt_die("Unexpected behavior with '%s'", mailbox);
}
}
XBT_INFO("Goodbye now!");
return 0;
}
/** Handle a given task */
static void handle_task(node_t node, msg_task_t task) {
XBT_DEBUG("Handling task %p", task);
char mailbox[MAILBOX_NAME_SIZE];
int i;
int j;
int min;
int max;
int next;
msg_task_t task_sent;
task_data_t req_data;
task_data_t task_data = (task_data_t) MSG_task_get_data(task);
e_task_type_t type = task_data->type;
// If the node is not ready keep the task for later
if (node->ready != 0 && !(type==TASK_JOIN_LAST_REPLY || type==TASK_JOIN_REPLY)) {
XBT_DEBUG("Task pending %u", type);
xbt_dynar_push(node->pending_tasks, &task);
return;
}
switch (type) {
/* Try to join the ring */
case TASK_JOIN:
next = routing_next(node, task_data->answer_id);
XBT_DEBUG("Join request from %08x forwarding to %08x", (unsigned)task_data->answer_id, (unsigned)next);
type = TASK_JOIN_LAST_REPLY;
req_data = xbt_new0(s_task_data_t,1);
req_data->answer_id = task_data->sender_id;
req_data->steps = task_data->steps + 1;
// if next different from current node forward the join
if (next!=node->id) {
get_mailbox(next, mailbox);
task_data->sender_id = node->id;
task_data->steps++;
task_sent = MSG_task_create(NULL, COMP_SIZE, COMM_SIZE, task_data);
if (MSG_task_send_with_timeout(task_sent, mailbox, timeout)== MSG_TIMEOUT) {
XBT_DEBUG("Timeout expired when forwarding join to next %d", next);
task_free(task_sent);
}
type = TASK_JOIN_REPLY;
}
// send back the current node state to the joining node
req_data->type = type;
req_data->sender_id = node->id;
get_mailbox(node->id, req_data->answer_to);
req_data->state = node_get_state(node);
task_sent = MSG_task_create(NULL, COMP_SIZE, COMM_SIZE, req_data);
if (MSG_task_send_with_timeout(task_sent, task_data->answer_to, timeout)== MSG_TIMEOUT) {
XBT_DEBUG("Timeout expired when sending back the current node state to the joining node to %d", node->id);
task_free(task_sent);
}
break;
/* Join reply from all the node touched by the join */
case TASK_JOIN_LAST_REPLY:
// if last node touched reply, copy its namespace set
// TODO: it works only if the two nodes are side to side (is it really the case ?)
j = (task_data->sender_id < node->id) ? -1 : 0;
for (i=0; i<NAMESPACE_SIZE/2; i++) {
node->namespace_set[i] = task_data->state->namespace_set[i-j];
node->namespace_set[NAMESPACE_SIZE-1-i] = task_data->state->namespace_set[NAMESPACE_SIZE-1-i-j-1];
}
node->namespace_set[NAMESPACE_SIZE/2+j] = task_data->sender_id;
node->ready += task_data->steps + 1;
/* no break */
case TASK_JOIN_REPLY:
XBT_DEBUG("Joining Reply");
// if first node touched reply, copy its neighborhood set
if (task_data->sender_id == node->known_id) {
node->neighborhood_set[0] = task_data->sender_id;
for (i=1; i<NEIGHBORHOOD_SIZE; i++)
node->neighborhood_set[i] = task_data->state->neighborhood_set[i-1];
}
// copy the corresponding routing table levels
min = (node->id==task_data->answer_id) ? 0 : shl(node->id, task_data->answer_id);
max = shl(node->id, task_data->sender_id)+1;
for (i=min;i<max;i++) {
int d = domain(node->id, i);
for (j=0; j<LEVEL_SIZE; j++)
if (d!=j)
node->routing_table[i][j] = task_data->state->routing_table[i][j];
}
node->ready--;
// if the node is ready, do all the pending tasks and send update to known nodes
if (node->ready==0) {
XBT_DEBUG("Node %i is ready!!!", node->id);
while (!xbt_dynar_is_empty(node->pending_tasks)) {
msg_task_t task;
xbt_dynar_shift(node->pending_tasks, &task);
handle_task(node, task);
}
for (i=0; i<NAMESPACE_SIZE; i++) {
j = node->namespace_set[i];
if (j!=-1) {
XBT_DEBUG("Send update to %i", j);
get_mailbox(j, mailbox);
req_data = xbt_new0(s_task_data_t,1);
req_data->answer_id = node->id;
req_data->steps = 0;
req_data->type = TASK_UPDATE;
req_data->sender_id = node->id;
get_mailbox(node->id, req_data->answer_to);
req_data->state = node_get_state(node);
task_sent = MSG_task_create(NULL, COMP_SIZE, COMM_SIZE, req_data);
if (MSG_task_send_with_timeout(task_sent, mailbox, timeout)== MSG_TIMEOUT) {
XBT_DEBUG("Timeout expired when sending update to %d", j);
task_free(task_sent);
}
}
}
}
break;
/* Received an update of state */
case TASK_UPDATE:
XBT_DEBUG("Task update %i !!!", node->id);
/* Update namespace ses */
XBT_INFO("Task update from %i !!!", task_data->sender_id);
XBT_INFO("Node:");
print_node_id(node);
print_node_namespace_set(node);
int curr_namespace_set[NAMESPACE_SIZE];
int task_namespace_set[NAMESPACE_SIZE+1];
// Copy the current namespace and the task state namespace with state->id in the middle
i=0;
for (; i<NAMESPACE_SIZE/2; i++){
curr_namespace_set[i] = node->namespace_set[i];
task_namespace_set[i] = task_data->state->namespace_set[i];
}
task_namespace_set[i] = task_data->state->id;
for (; i<NAMESPACE_SIZE; i++){
curr_namespace_set[i] = node->namespace_set[i];
task_namespace_set[i+1] = task_data->state->namespace_set[i];
}
// get the index of values before and after node->id in task_namespace
min = -1;
max = -1;
for (i=0; i<=NAMESPACE_SIZE; i++) {
j = task_namespace_set[i];
if (j != -1 && j < node->id)
min = i;
if (j != -1 && max == -1 && j > node->id)
max = i;
}
// add lower elements
j = NAMESPACE_SIZE/2-1;
for (i=NAMESPACE_SIZE/2-1; i>=0; i--) {
if (min < 0 || curr_namespace_set[j] > task_namespace_set[min]) {
node->namespace_set[i] = curr_namespace_set[j];
j--;
} else if (curr_namespace_set[j] == task_namespace_set[min]) {
node->namespace_set[i] = curr_namespace_set[j];
j--;
min--;
} else {
node->namespace_set[i] = task_namespace_set[min];
min--;
}
}
// add greater elements
j = NAMESPACE_SIZE/2;
for (i=NAMESPACE_SIZE/2; i<NAMESPACE_SIZE; i++) {
if (min<0 || max>=NAMESPACE_SIZE) {
node->namespace_set[i] = curr_namespace_set[j];
j++;
} else if (max >= 0){
if (curr_namespace_set[j] == -1 || curr_namespace_set[j] > task_namespace_set[max]) {
node->namespace_set[i] = task_namespace_set[max];
max++;
} else if (curr_namespace_set[j] == task_namespace_set[max]) {
node->namespace_set[i] = curr_namespace_set[j];
j++;
max++;
} else {
node->namespace_set[i] = curr_namespace_set[j];
j++;
}
}
}
/* Update routing table */
for (i=shl(node->id, task_data->state->id); i<LEVELS_COUNT; i++) {
for (j=0; j<LEVEL_SIZE; j++) {
if (node->routing_table[i][j]==-1 && task_data->state->routing_table[i][j]==-1)
node->routing_table[i][j] = task_data->state->routing_table[i][j];
}
}
break;
default:
THROW_IMPOSSIBLE;
}
task_free(task);
}
int master(int argc, char *argv[])
{
int slaves_count = 0;
msg_host_t *slaves = NULL;
int number_of_tasks = 0;
double task_comp_size = 0;
double task_comm_size = 0;
int i;
number_of_tasks = TASK_COUNT_PER_HOST*argc;
task_comp_size = TASK_COMP_SIZE;
task_comm_size = TASK_COMM_SIZE;
{ /* Process organization */
slaves_count = argc;
slaves = xbt_new0(msg_host_t, slaves_count);
for (i = 0; i < argc; i++) {
slaves[i] = MSG_get_host_by_name(argv[i]);
if (slaves[i] == NULL) {
XBT_INFO("Unknown host %s. Stopping Now! ", argv[i]);
abort();
}
}
}
XBT_INFO("Got %d slave(s) :", slaves_count);
for (i = 0; i < slaves_count; i++)
XBT_INFO("%s", MSG_host_get_name(slaves[i]));
XBT_INFO("Got %d task to process :", number_of_tasks);
for (i = 0; i < number_of_tasks; i++) {
msg_task_t task = MSG_task_create("Task", task_comp_size, task_comm_size,
xbt_new0(double, 1));
int a;
*((double *) task->data) = MSG_get_clock();
a = MSG_task_send_with_timeout(task,MSG_host_get_name(slaves[i % slaves_count]),10.0);
if (a == MSG_OK) {
XBT_INFO("Send completed");
} else if (a == MSG_HOST_FAILURE) {
XBT_INFO
("Gloups. The cpu on which I'm running just turned off!. See you!");
free(task->data);
MSG_task_destroy(task);
free(slaves);
return 0;
} else if (a == MSG_TRANSFER_FAILURE) {
XBT_INFO
("Mmh. Something went wrong with '%s'. Nevermind. Let's keep going!",
MSG_host_get_name(slaves[i % slaves_count]));
free(task->data);
MSG_task_destroy(task);
} else if (a == MSG_TIMEOUT) {
XBT_INFO
("Mmh. Got timeouted while speaking to '%s'. Nevermind. Let's keep going!",
MSG_host_get_name(slaves[i % slaves_count]));
free(task->data);
MSG_task_destroy(task);
} else {
XBT_INFO("Hey ?! What's up ? ");
xbt_die( "Unexpected behavior");
}
}
XBT_INFO
("All tasks have been dispatched. Let's tell everybody the computation is over.");
for (i = 0; i < slaves_count; i++) {
msg_task_t task = MSG_task_create("finalize", 0, 0, FINALIZE);
int a = MSG_task_send_with_timeout(task,MSG_host_get_name(slaves[i]),1.0);
if (a == MSG_OK)
continue;
if (a == MSG_HOST_FAILURE) {
XBT_INFO
("Gloups. The cpu on which I'm running just turned off!. See you!");
MSG_task_destroy(task);
free(slaves);
return 0;
} else if (a == MSG_TRANSFER_FAILURE) {
XBT_INFO("Mmh. Can't reach '%s'! Nevermind. Let's keep going!",
MSG_host_get_name(slaves[i]));
MSG_task_destroy(task);
} else if (a == MSG_TIMEOUT) {
XBT_INFO
("Mmh. Got timeouted while speaking to '%s'. Nevermind. Let's keep going!",
MSG_host_get_name(slaves[i % slaves_count]));
MSG_task_destroy(task);
} else {
XBT_INFO("Hey ?! What's up ? ");
xbt_die("Unexpected behavior with '%s': %d", MSG_host_get_name(slaves[i]), a);
}
}
XBT_INFO("Goodbye now!");
free(slaves);
return 0;
} /* end_of_master */
