JNIEXPORT void JNICALL Java_org_simgrid_msg_Comm_waitAll(JNIEnv *env, jclass cls, jobjectArray jcomms, jdouble timeout)
{
int count;
msg_comm_t* comms = jarray_to_commArray(env, jcomms, &count);
if (not comms)
return;
MSG_comm_waitall(comms, count, static_cast<double>(timeout));
delete[] comms;
}
static void action_reduce(const char *const *action)
{
int i;
char *reduce_identifier;
char mailbox[80];
double comm_size = parse_double(action[2]);
double comp_size = parse_double(action[3]);
msg_task_t comp_task = NULL;
const char *process_name;
double clock = MSG_get_clock();
process_globals_t counters =
(process_globals_t) MSG_process_get_data(MSG_process_self());
xbt_assert(communicator_size, "Size of Communicator is not defined, "
"can't use collective operations");
process_name = MSG_process_get_name(MSG_process_self());
reduce_identifier = bprintf("reduce_%d", counters->reduce_counter++);
if (!strcmp(process_name, "p0")) {
XBT_DEBUG("%s: %s is the Root", reduce_identifier, process_name);
msg_comm_t *comms = xbt_new0(msg_comm_t, communicator_size - 1);
msg_task_t *tasks = xbt_new0(msg_task_t, communicator_size - 1);
for (i = 1; i < communicator_size; i++) {
sprintf(mailbox, "%s_p%d_p0", reduce_identifier, i);
comms[i - 1] = MSG_task_irecv(&(tasks[i - 1]), mailbox);
}
MSG_comm_waitall(comms, communicator_size - 1, -1);
for (i = 1; i < communicator_size; i++) {
MSG_comm_destroy(comms[i - 1]);
MSG_task_destroy(tasks[i - 1]);
}
xbt_free(comms);
xbt_free(tasks);
comp_task = MSG_task_create("reduce_comp", comp_size, 0, NULL);
XBT_DEBUG("%s: computing 'reduce_comp'", reduce_identifier);
MSG_task_execute(comp_task);
MSG_task_destroy(comp_task);
XBT_DEBUG("%s: computed", reduce_identifier);
} else {
XBT_DEBUG("%s: %s sends", reduce_identifier, process_name);
sprintf(mailbox, "%s_%s_p0", reduce_identifier, process_name);
XBT_DEBUG("put on %s", mailbox);
MSG_task_send(MSG_task_create(reduce_identifier, 0, comm_size, NULL),
mailbox);
}
log_action(action, MSG_get_clock() - clock);
xbt_free(reduce_identifier);
}
static void action_bcast(const char *const *action)
{
int i;
char *bcast_identifier;
char mailbox[80];
double comm_size = parse_double(action[2]);
msg_task_t task = NULL;
const char *process_name;
double clock = MSG_get_clock();
process_globals_t counters =
(process_globals_t) MSG_process_get_data(MSG_process_self());
xbt_assert(communicator_size, "Size of Communicator is not defined, "
"can't use collective operations");
process_name = MSG_process_get_name(MSG_process_self());
bcast_identifier = bprintf("bcast_%d", counters->bcast_counter++);
if (!strcmp(process_name, "p0")) {
XBT_DEBUG("%s: %s is the Root", bcast_identifier, process_name);
msg_comm_t *comms = xbt_new0(msg_comm_t, communicator_size - 1);
for (i = 1; i < communicator_size; i++) {
sprintf(mailbox, "%s_p0_p%d", bcast_identifier, i);
comms[i - 1] =
MSG_task_isend(MSG_task_create(mailbox, 0, comm_size, NULL), mailbox);
}
MSG_comm_waitall(comms, communicator_size - 1, -1);
for (i = 1; i < communicator_size; i++)
MSG_comm_destroy(comms[i - 1]);
xbt_free(comms);
XBT_DEBUG("%s: all messages sent by %s have been received",
bcast_identifier, process_name);
} else {
sprintf(mailbox, "%s_p0_%s", bcast_identifier, process_name);
MSG_task_receive(&task, mailbox);
MSG_task_destroy(task);
XBT_DEBUG("%s: %s has received", bcast_identifier, process_name);
}
log_action(action, MSG_get_clock() - clock);
xbt_free(bcast_identifier);
}
/*
* Broadcast the jobs to the nodes of the grid (except to node 0)
*/
static void broadcast_jobs(node_job_t *jobs)
{
int node;
char node_mbox[MAILBOX_NAME_SIZE];
msg_task_t task;
msg_comm_t comms[GRID_NUM_NODES - 1] = {0};
XBT_VERB("Broadcast Jobs");
for (node = 1; node < GRID_NUM_NODES; node++) {
task = MSG_task_create("Job", 100, 100, jobs[node-1]);
snprintf(node_mbox, MAILBOX_NAME_SIZE - 1, "%d", node);
comms[node-1] = MSG_task_isend(task, node_mbox);
}
MSG_comm_waitall(comms, GRID_NUM_NODES-1, -1);
for (node = 1; node < GRID_NUM_NODES; node++)
MSG_comm_destroy(comms[node - 1]);
}
void peer_shutdown(peer_t p)
{
unsigned int size = xbt_dynar_length(p->pending_sends);
unsigned int idx;
msg_comm_t *comms = xbt_new(msg_comm_t, size);
for (idx = 0; idx < size; idx++) {
comms[idx] = xbt_dynar_get_as(p->pending_sends, idx, msg_comm_t);
}
XBT_DEBUG("Waiting for sends to finish before shutdown...");
MSG_comm_waitall(comms, size, PEER_SHUTDOWN_DEADLINE);
for (idx = 0; idx < size; idx++) {
MSG_comm_destroy(comms[idx]);
}
xbt_free(comms);
}
static void receive_results(result_t *results) {
int node;
msg_comm_t comms[GRID_NUM_NODES-1] = {0};
msg_task_t tasks[GRID_NUM_NODES-1] = {0};
XBT_VERB("Receive Results.");
/* Get the result from the nodes in the GRID */
for (node = 1; node < GRID_NUM_NODES; node++) {
comms[node-1] = MSG_task_irecv(&tasks[node-1], "0");
}
MSG_comm_waitall(comms, GRID_NUM_NODES - 1, -1);
for (node = 1; node < GRID_NUM_NODES; node++)
MSG_comm_destroy(comms[node - 1]);
/* Reconstruct the result matrix */
for (node = 1; node < GRID_NUM_NODES; node++) {
results[node] = (result_t)MSG_task_get_data(tasks[node-1]);
MSG_task_destroy(tasks[node-1]);
}
}
/** Sender function */
int sender(int argc, char *argv[])
{
long number_of_tasks = atol(argv[1]);
double task_comp_size = atof(argv[2]);
double task_comm_size = atof(argv[3]);
long receivers_count = atol(argv[4]);
msg_comm_t *comm = xbt_new(msg_comm_t, number_of_tasks + receivers_count);
int i;
msg_task_t task = NULL;
for (i = 0; i < number_of_tasks; i++) {
char mailbox[256];
char sprintf_buffer[256];
sprintf(mailbox, "receiver-%ld", i % receivers_count);
sprintf(sprintf_buffer, "Task_%d", i);
task =
MSG_task_create(sprintf_buffer, task_comp_size, task_comm_size,
NULL);
comm[i] = MSG_task_isend(task, mailbox);
XBT_INFO("Send to receiver-%ld Task_%d", i % receivers_count, i);
}
for (i = 0; i < receivers_count; i++) {
char mailbox[80];
sprintf(mailbox, "receiver-%ld", i % receivers_count);
task = MSG_task_create("finalize", 0, 0, 0);
comm[i + number_of_tasks] = MSG_task_isend(task, mailbox);
XBT_INFO("Send to receiver-%ld finalize", i % receivers_count);
}
/* Here we are waiting for the completion of all communications */
MSG_comm_waitall(comm, (number_of_tasks + receivers_count), -1);
for (i = 0; i < number_of_tasks + receivers_count; i++)
MSG_comm_destroy(comm[i]);
XBT_INFO("Goodbye now!");
xbt_free(comm);
return 0;
} /* end_of_sender */
