/** 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]);
double sleep_start_time = atof(argv[5]);
double sleep_test_time = atof(argv[6]);
XBT_INFO("sleep_start_time : %f , sleep_test_time : %f", sleep_start_time,
sleep_test_time);
msg_comm_t comm = NULL;
int i;
m_task_t task = NULL;
MSG_process_sleep(sleep_start_time);
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 = MSG_task_isend(task, mailbox);
XBT_INFO("Send to receiver-%ld Task_%d", i % receivers_count, i);
if (sleep_test_time == 0) {
MSG_comm_wait(comm, -1);
} else {
while (MSG_comm_test(comm) == 0) {
MSG_process_sleep(sleep_test_time);
};
MSG_comm_destroy(comm);
}
}
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 = MSG_task_isend(task, mailbox);
XBT_INFO("Send to receiver-%ld finalize", i % receivers_count);
if (sleep_test_time == 0) {
MSG_comm_wait(comm, -1);
} else {
while (MSG_comm_test(comm) == 0) {
MSG_process_sleep(sleep_test_time);
};
MSG_comm_destroy(comm);
}
}
XBT_INFO("Goodbye now!");
return 0;
} /* end_of_sender */
static int server(int argc, char *argv[])
{
msg_task_t task = MSG_task_create("a", 0, 0, (char*)"Some data");
MSG_task_isend(task, "mailbox");
xbt_assert(MSG_task_listen("mailbox")); // True (1)
XBT_INFO("Task listen works on regular mailboxes");
task = NULL;
MSG_task_receive(&task, "mailbox");
xbt_assert(!strcmp("Some data", MSG_task_get_data(task)), "Data received: %s", (char*)MSG_task_get_data(task));
MSG_task_destroy(task);
XBT_INFO("Data successfully received from regular mailbox");
MSG_mailbox_set_async("mailbox2");
task = MSG_task_create("b", 0, 0, (char*)"More data");
MSG_task_isend(task, "mailbox2");
xbt_assert(MSG_task_listen("mailbox2")); // used to break.
XBT_INFO("Task listen works on asynchronous mailboxes");
task = NULL;
MSG_task_receive(&task, "mailbox2");
xbt_assert(!strcmp("More data", MSG_task_get_data(task)));
MSG_task_destroy(task);
XBT_INFO("Data successfully received from asynchronous mailbox");
return 0;
}
/* Sender process expects 6 arguments: */
static int sender(int argc, char *argv[])
{
long number_of_tasks = xbt_str_parse_int(argv[1], "Invalid amount of tasks: %s"); /* - number of tasks */
double task_comp_size = xbt_str_parse_double(argv[2], "Invalid computational size: %s"); /* - computational cost */
double task_comm_size = xbt_str_parse_double(argv[3], "Invalid communication size: %s"); /* - communication cost */
long receivers_count = xbt_str_parse_int(argv[4], "Invalid amount of receivers: %s"); /* - number of receivers */
double sleep_start_time = xbt_str_parse_double(argv[5], "Invalid sleep start time: %s"); /* - start time */
double sleep_test_time = xbt_str_parse_double(argv[6], "Invalid test time: %s"); /* - test time */
XBT_INFO("sleep_start_time : %f , sleep_test_time : %f", sleep_start_time, sleep_test_time);
int i;
msg_task_t task = NULL;
msg_comm_t comm = NULL;
MSG_process_sleep(sleep_start_time);
for (i = 0; i < number_of_tasks; i++) {
char mailbox[256];
char snprintf_buffer[256];
snprintf(mailbox,255, "receiver-%ld", i % receivers_count);
snprintf(snprintf_buffer,255, "Task_%d", i);
/* This process first creates a task and send it asynchronously with @ref MSG_task_isend. Then, if: */
task = MSG_task_create(snprintf_buffer, task_comp_size, task_comm_size, NULL);
comm = MSG_task_isend(task, mailbox);
XBT_INFO("Send to receiver-%ld Task_%d", i % receivers_count, i);
if (sleep_test_time > 0) { /* - "test_time" is set to 0, wait on @ref MSG_comm_wait */
while (MSG_comm_test(comm) == 0) { /* - Call @ref MSG_comm_test every "test_time" otherwise */
MSG_process_sleep(sleep_test_time);
};
} else {
MSG_comm_wait(comm, -1);
}
MSG_comm_destroy(comm);
}
for (i = 0; i < receivers_count; i++) {
char mailbox[80];
snprintf(mailbox,79, "receiver-%ld", i % receivers_count);
task = MSG_task_create("finalize", 0, 0, 0);
comm = MSG_task_isend(task, mailbox);
XBT_INFO("Send to receiver-%ld finalize", i % receivers_count);
if (sleep_test_time > 0) {
while (MSG_comm_test(comm) == 0) {
MSG_process_sleep(sleep_test_time);
}
} else {
MSG_comm_wait(comm, -1);
}
MSG_comm_destroy(comm);
}
XBT_INFO("Goodbye now!");
return 0;
}
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;
}
static void peer_forward_msg(peer_t peer, message_t msg)
{
msg_task_t task = task_message_data_new(NULL, msg->data_length);
msg_comm_t comm = NULL;
XBT_DEBUG("Sending (isend) from %s into mailbox %s", peer->me, peer->next);
comm = MSG_task_isend(task, peer->next);
queue_pending_connection(comm, peer->pending_sends);
}
/** 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]);
int diff_com = atol(argv[5]);
double coef = 0;
xbt_dynar_t d = xbt_dynar_new(sizeof(msg_comm_t), NULL);
int i;
msg_task_t task;
char mailbox[256];
char sprintf_buffer[256];
msg_comm_t comm;
for (i = 0; i < number_of_tasks; i++) {
if (diff_com == 0)
coef = 1;
else
coef = (i + 1);
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 / coef, NULL);
comm = MSG_task_isend(task, mailbox);
xbt_dynar_push_as(d, msg_comm_t, comm);
XBT_INFO("Send to receiver-%ld %s comm_size %f", i % receivers_count,
sprintf_buffer, task_comm_size / coef);
}
/* Here we are waiting for the completion of all communications */
while (!xbt_dynar_is_empty(d)) {
xbt_dynar_remove_at(d, MSG_comm_waitany(d), &comm);
MSG_comm_destroy(comm);
}
xbt_dynar_free(&d);
/* Here we are waiting for the completion of all tasks */
sprintf(mailbox, "finalize");
msg_comm_t res_irecv;
_XBT_GNUC_UNUSED msg_error_t res_wait;
for (i = 0; i < receivers_count; i++) {
task = NULL;
res_irecv = MSG_task_irecv(&(task), mailbox);
res_wait = MSG_comm_wait(res_irecv, -1);
xbt_assert(res_wait == MSG_OK, "MSG_comm_wait failed");
MSG_comm_destroy(res_irecv);
MSG_task_destroy(task);
}
XBT_INFO("Goodbye now!");
return 0;
} /* end_of_sender */
void return_task(char task_name[],m_task_t received_task,double output_size){
m_task_t task = NULL;
task_data *received_task_data = (task_data *) received_task->data;
//write_log(received_task_data->starttime,MSG_get_clock(),"process time");
char mailbox[100];
strcpy(mailbox,received_task_data->sender);
task = MSG_task_create(task_name,0,output_size,NULL);
task->data = received_task_data;
XBT_INFO("sending task %lf response",received_task_data->id);
MSG_task_isend(task,mailbox);
}
int service_invoke_cordel(char role[],char method_name[],double size,task_data *data){
msg_comm_t msg_send;
m_task_t task = MSG_task_create(method_name,0,size,NULL);
task->data = data;
msg_send = MSG_task_isend(task,role);
task_data data_to_print = *(task_data *)task->data;
XBT_INFO("sending task %lf to %s",data_to_print.id,role);
//double endtime = MSG_get_clock();
//write_log(data_received.starttime,endtime);
}
/** 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 */
int client(int argc, char *argv[])
{
msg_task_t task1 = MSG_task_create(argv[1], 0, 10000, NULL);
char *mbox = bprintf("mymailbox%s", argv[1]);
XBT_INFO("Send %s!", argv[1]);
msg_comm_t comm = MSG_task_isend(task1, mbox);
MSG_comm_wait(comm, -1);
xbt_free(mbox);
return 0;
}
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);
}
/** 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 */
int client(int argc, char *argv[])
{
msg_comm_t comm;
char *mbox;
msg_task_t task1 =
MSG_task_create("task", 0, 10000, (void *) atol(argv[1]));
mbox = bprintf("mymailbox%s", argv[1]);
XBT_INFO("Send %d!", atoi(argv[1]));
comm = MSG_task_isend(task1, mbox);
MSG_comm_wait(comm, -1);
xbt_free(mbox);
return 0;
}
static void action_Isend(const char *const *action)
{
char to[250];
const char *size = action[3];
double clock = MSG_get_clock();
process_globals_t globals =
(process_globals_t) MSG_process_get_data(MSG_process_self());
sprintf(to, "%s_%s", MSG_process_get_name(MSG_process_self()), action[2]);
msg_comm_t comm =
MSG_task_isend(MSG_task_create(to, 0, parse_double(size), NULL), to);
xbt_dynar_push(globals->isends, &comm);
XBT_DEBUG("Isend on %s", MSG_process_get_name(MSG_process_self()));
log_action(action, MSG_get_clock() - clock);
asynchronous_cleanup();
}
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;
}
/*
* 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]);
}
int broker(int argc, char *argv[]){
//set number of request
int requests_per_second= atoi(argv[1]);
double static broker_id = 0;
request list_requests[50];
int list_requests_len = 0;
//set mailbox
char mailbox[50];
sprintf(mailbox,"%s_%lf",argv[0],broker_id++);
msg_comm_t msg_send;
//create list of requests
int i;
for( i = 2;i < argc;i = i+3){
make_request(&list_requests[list_requests_len++],argv[i],argv[i+1],argv[i+2]);
}
//send requests
int j;
for(j =0;j < list_requests_len;j++){
m_task_t task = MSG_task_create(list_requests[j].method,0,
list_requests[j].input_size,NULL);
task->data = xbt_new(task_data,1);
create_task_data((task_data *) task->data,task_id++,mailbox);
msg_send = MSG_task_isend(task,list_requests[j].role);
task_data data_to_print = *(task_data *)task->data;
XBT_INFO("sending task %lf to %s",data_to_print.id,list_requests[j].role );
//receive response
task_data data_received = receive_task(mailbox);
XBT_INFO("received task %lf", data_received.id);
double endtime = MSG_get_clock();
write_log(data_received.starttime,endtime,"time_total");
}
XBT_INFO("ending choreography");
}
