some useless cleanups

diff --git a/examples/msg/pmm/msg_pmm.c b/examples/msg/pmm/msg_pmm.c
index 587742a..c9ef867 100644 (file)
--- a/examples/msg/pmm/msg_pmm.c
+++ b/examples/msg/pmm/msg_pmm.c
@@ -19,9 +19,8 @@
 
 XBT_LOG_NEW_DEFAULT_CATEGORY(msg_pmm, "Messages specific for this msg example");
 
 
 XBT_LOG_NEW_DEFAULT_CATEGORY(msg_pmm, "Messages specific for this msg example");
 

-/* This example should always be executed using a deployment of
- * GRID_SIZE * GRID_SIZE nodes. */
-#define GRID_SIZE 3    /* Modify to adjust the grid's size */
+/* This example should always be executed using a deployment of GRID_SIZE * GRID_SIZE nodes. */
+#define GRID_SIZE 3           /* Modify to adjust the grid's size */

 #define NODE_MATRIX_SIZE 300  /* Amount of work done by each node*/
 
 #define GRID_NUM_NODES GRID_SIZE * GRID_SIZE
 #define NODE_MATRIX_SIZE 300  /* Amount of work done by each node*/
 
 #define GRID_NUM_NODES GRID_SIZE * GRID_SIZE


@@ -61,7 +60,6 @@ static void task_cleanup(void *arg);
 
 int node(int argc, char **argv)
 {
 
 int node(int argc, char **argv)
 {

-  int k, myid;

   char my_mbox[MAILBOX_NAME_SIZE];
   node_job_t myjob, jobs[GRID_NUM_NODES];
   xbt_matrix_t A, B, C, sA, sB, sC;
   char my_mbox[MAILBOX_NAME_SIZE];
   node_job_t myjob, jobs[GRID_NUM_NODES];
   xbt_matrix_t A, B, C, sA, sB, sC;


@@ -70,7 +68,7 @@ int node(int argc, char **argv)
   xbt_assert(argc != 1, "Wrong number of arguments for this node");
 
   /* Initialize the node's data-structures */
   xbt_assert(argc != 1, "Wrong number of arguments for this node");
 
   /* Initialize the node's data-structures */

-  myid = xbt_str_parse_int(argv[1], "Invalid ID received as first node parameter: %s");
+  int myid = xbt_str_parse_int(argv[1], "Invalid ID received as first node parameter: %s");

   snprintf(my_mbox, MAILBOX_NAME_SIZE - 1, "%d", myid);
   sC = xbt_matrix_double_new_zeros(NODE_MATRIX_SIZE, NODE_MATRIX_SIZE);
 
   snprintf(my_mbox, MAILBOX_NAME_SIZE - 1, "%d", myid);
   sC = xbt_matrix_double_new_zeros(NODE_MATRIX_SIZE, NODE_MATRIX_SIZE);
 


@@ -89,14 +87,14 @@ int node(int argc, char **argv)
     /* Broadcast the rest of the jobs to the other nodes */
     broadcast_jobs(jobs + 1);
 
     /* Broadcast the rest of the jobs to the other nodes */
     broadcast_jobs(jobs + 1);
 

-  }else{
+  } else {

     A = B = C = NULL;           /* Avoid warning at compilation */
     myjob = wait_job(myid);
   }
 
   /* Multiplication main-loop */
   XBT_VERB("Start Multiplication's Main-loop");
     A = B = C = NULL;           /* Avoid warning at compilation */
     myjob = wait_job(myid);
   }
 
   /* Multiplication main-loop */
   XBT_VERB("Start Multiplication's Main-loop");

-  for(k=0; k < GRID_SIZE; k++){
+  for (int k=0; k < GRID_SIZE; k++){

     if(k == myjob->col){
       XBT_VERB("Broadcast sA(%d,%d) to row %d", myjob->row, k, myjob->row);
       broadcast_matrix(myjob->A, NEIGHBOURS_COUNT, myjob->nodes_in_row);
     if(k == myjob->col){
       XBT_VERB("Broadcast sA(%d,%d) to row %d", myjob->row, k, myjob->row);
       broadcast_matrix(myjob->A, NEIGHBOURS_COUNT, myjob->nodes_in_row);


@@ -181,20 +179,18 @@ int node(int argc, char **argv)
  */
 static void broadcast_jobs(node_job_t *jobs)
 {
  */
 static void broadcast_jobs(node_job_t *jobs)
 {

-  int node;

   char node_mbox[MAILBOX_NAME_SIZE];
   char node_mbox[MAILBOX_NAME_SIZE];

-  msg_task_t task;

   msg_comm_t comms[GRID_NUM_NODES - 1] = {0};
 
   XBT_VERB("Broadcast Jobs");
   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]);
+  for (int node = 1; node < GRID_NUM_NODES; node++){
+    msg_task_t 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);
     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++)
+  for (int node = 1; node < GRID_NUM_NODES; node++)

     MSG_comm_destroy(comms[node - 1]);
 }
 
     MSG_comm_destroy(comms[node - 1]);
 }
 


@@ -202,12 +198,10 @@ static node_job_t wait_job(int selfid)
 {
   msg_task_t task = NULL;
   char self_mbox[MAILBOX_NAME_SIZE];
 {
   msg_task_t task = NULL;
   char self_mbox[MAILBOX_NAME_SIZE];

-  node_job_t job;
-  msg_error_t err;

   snprintf(self_mbox, MAILBOX_NAME_SIZE - 1, "%d", selfid);
   snprintf(self_mbox, MAILBOX_NAME_SIZE - 1, "%d", selfid);

-  err = MSG_task_receive(&task, self_mbox);
+  msg_error_t err = MSG_task_receive(&task, self_mbox);

   xbt_assert(err == MSG_OK, "Error while receiving from %s (%d)", self_mbox, (int)err);
   xbt_assert(err == MSG_OK, "Error while receiving from %s (%d)", self_mbox, (int)err);

-  job = (node_job_t)MSG_task_get_data(task);
+  node_job_t job  = (node_job_t)MSG_task_get_data(task);

   MSG_task_destroy(task);
   XBT_VERB("Got Job (%d,%d)", job->row, job->col);
 
   MSG_task_destroy(task);
   XBT_VERB("Got Job (%d,%d)", job->row, job->col);
 


@@ -216,15 +210,12 @@ static node_job_t wait_job(int selfid)
 
 static void broadcast_matrix(xbt_matrix_t M, int num_nodes, int *nodes)
 {
 
 static void broadcast_matrix(xbt_matrix_t M, int num_nodes, int *nodes)
 {

-  int node;

   char node_mbox[MAILBOX_NAME_SIZE];
   char node_mbox[MAILBOX_NAME_SIZE];

-  msg_task_t task;
-  xbt_matrix_t sM;

 
 

-  for(node=0; node < num_nodes; node++){
+  for(int node=0; node < num_nodes; node++){

     snprintf(node_mbox, MAILBOX_NAME_SIZE - 1, "%d", nodes[node]);
     snprintf(node_mbox, MAILBOX_NAME_SIZE - 1, "%d", nodes[node]);

-    sM = xbt_matrix_new_sub(M, NODE_MATRIX_SIZE, NODE_MATRIX_SIZE, 0, 0, NULL);
-    task = MSG_task_create("sub-matrix", 100, 100, sM);
+    xbt_matrix_t sM  = xbt_matrix_new_sub(M, NODE_MATRIX_SIZE, NODE_MATRIX_SIZE, 0, 0, NULL);
+    msg_task_t task = MSG_task_create("sub-matrix", 100, 100, sM);

     MSG_task_dsend(task, node_mbox, task_cleanup);
     XBT_DEBUG("sub-matrix sent to %s", node_mbox);
   }
     MSG_task_dsend(task, node_mbox, task_cleanup);
     XBT_DEBUG("sub-matrix sent to %s", node_mbox);
   }


@@ -234,14 +225,12 @@ static void get_sub_matrix(xbt_matrix_t *sM, int selfid)
 {
   msg_task_t task = NULL;
   char node_mbox[MAILBOX_NAME_SIZE];
 {
   msg_task_t task = NULL;
   char node_mbox[MAILBOX_NAME_SIZE];

-  msg_error_t err;

 
   XBT_VERB("Get sub-matrix");
 
   snprintf(node_mbox, MAILBOX_NAME_SIZE - 1, "%d", selfid);
 
   XBT_VERB("Get sub-matrix");
 
   snprintf(node_mbox, MAILBOX_NAME_SIZE - 1, "%d", selfid);

-  err = MSG_task_receive(&task, node_mbox);
-  if (err != MSG_OK)
-    xbt_die("Error while receiving from %s (%d)", node_mbox, (int)err);
+  msg_error_t err = MSG_task_receive(&task, node_mbox);
+  xbt_assert(err == MSG_OK, "Error while receiving from %s (%d)", node_mbox, (int)err);

   *sM = (xbt_matrix_t)MSG_task_get_data(task);
   MSG_task_destroy(task);
 }
   *sM = (xbt_matrix_t)MSG_task_get_data(task);
   MSG_task_destroy(task);
 }


@@ -255,12 +244,9 @@ static void task_cleanup(void *arg){
 
 int main(int argc, char *argv[])
 {
 
 int main(int argc, char *argv[])
 {

-#ifdef BENCH_THIS_CODE
-  xbt_os_cputimer_t timer = xbt_os_timer_new();
-#endif
+  xbt_os_timer_t timer = xbt_os_timer_new();

 
   MSG_init(&argc, argv);
 
   MSG_init(&argc, argv);

-

   MSG_create_environment(argv[1]);
 
   MSG_function_register("node", node);
   MSG_create_environment(argv[1]);
 
   MSG_function_register("node", node);


@@ -274,13 +260,9 @@ int main(int argc, char *argv[])
     xbt_free(hostname);
   }
 
     xbt_free(hostname);
   }
 

-#ifdef BENCH_THIS_CODE

   xbt_os_cputimer_start(timer);
   xbt_os_cputimer_start(timer);

-#endif

   msg_error_t res = MSG_main();
   msg_error_t res = MSG_main();

-#ifdef BENCH_THIS_CODE

   xbt_os_cputimer_stop(timer);
   xbt_os_cputimer_stop(timer);

-#endif

   XBT_CRITICAL("Simulated time: %g", MSG_get_clock());
 
   return res != MSG_OK;
   XBT_CRITICAL("Simulated time: %g", MSG_get_clock());
 
   return res != MSG_OK;


@@ -288,9 +270,9 @@ int main(int argc, char *argv[])
 
 static void create_jobs(xbt_matrix_t A, xbt_matrix_t B, node_job_t *jobs)
 {
 
 static void create_jobs(xbt_matrix_t A, xbt_matrix_t B, node_job_t *jobs)
 {

-  int node, j, k, row = 0, col = 0;
+  int row = 0, col = 0;

 
 

-  for (node = 0; node < GRID_NUM_NODES; node++){
+  for (int node = 0; node < GRID_NUM_NODES; node++){

     XBT_VERB("Create job %d", node);
     jobs[node] = xbt_new0(s_node_job_t, 1);
     jobs[node]->row = row;
     XBT_VERB("Create job %d", node);
     jobs[node] = xbt_new0(s_node_job_t, 1);
     jobs[node]->row = row;


@@ -298,14 +280,14 @@ static void create_jobs(xbt_matrix_t A, xbt_matrix_t B, node_job_t *jobs)
 
     /* Compute who are the nodes in the same row and column */
     /* than the node receiving this job */
 
     /* Compute who are the nodes in the same row and column */
     /* than the node receiving this job */

-    for (j = 0, k = 0; j < GRID_SIZE; j++) {
+    for (int j = 0, k = 0; j < GRID_SIZE; j++) {

       if (node != (GRID_SIZE * row) + j) {
         jobs[node]->nodes_in_row[k] = (GRID_SIZE * row) + j;
         k++;
       }
     }
 
       if (node != (GRID_SIZE * row) + j) {
         jobs[node]->nodes_in_row[k] = (GRID_SIZE * row) + j;
         k++;
       }
     }
 

-    for (j = 0, k = 0; j < GRID_SIZE; j++) {
+    for (int j = 0, k = 0; j < GRID_SIZE; j++) {

       if (node != (GRID_SIZE * j) + col) {
         jobs[node]->nodes_in_col[k] = (GRID_SIZE * j) + col;
         k++;
       if (node != (GRID_SIZE * j) + col) {
         jobs[node]->nodes_in_col[k] = (GRID_SIZE * j) + col;
         k++;


@@ -325,24 +307,22 @@ static void create_jobs(xbt_matrix_t A, xbt_matrix_t B, node_job_t *jobs)
   }
 }
 
   }
 }
 

-static void receive_results(result_t *results){
-  int node;
+static void receive_results(result_t *results) {

   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 */
   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++){
+  for (int node = 1; node < GRID_NUM_NODES; node++)

    comms[node-1] = MSG_task_irecv(&tasks[node-1], "0");
    comms[node-1] = MSG_task_irecv(&tasks[node-1], "0");

-  }

 
   MSG_comm_waitall(comms, GRID_NUM_NODES - 1, -1);
 
   MSG_comm_waitall(comms, GRID_NUM_NODES - 1, -1);

-  for (node = 1; node < GRID_NUM_NODES; node++)
+  for (int node = 1; node < GRID_NUM_NODES; node++)

     MSG_comm_destroy(comms[node - 1]);
 
   /* Reconstruct the result matrix */
     MSG_comm_destroy(comms[node - 1]);
 
   /* Reconstruct the result matrix */

-  for (node = 1; node < GRID_NUM_NODES; node++){
+  for (int node = 1; node < GRID_NUM_NODES; node++){

     results[node] = (result_t)MSG_task_get_data(tasks[node-1]);
     MSG_task_destroy(tasks[node-1]);
   }
     results[node] = (result_t)MSG_task_get_data(tasks[node-1]);
     MSG_task_destroy(tasks[node-1]);
   }

diff --git a/include/simgrid/msg.h b/include/simgrid/msg.h
index 98a7fc8..fe968e2 100644 (file)
--- a/include/simgrid/msg.h
+++ b/include/simgrid/msg.h
@@ -437,20 +437,14 @@ XBT_PUBLIC(msg_error_t)
     MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, double timeout,
                      msg_host_t host, double rate);
 
     MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, double timeout,
                      msg_host_t host, double rate);
 

-XBT_PUBLIC(msg_error_t)
-    MSG_task_receive_with_timeout_bounded(msg_task_t * task, const char *alias,
-                              double timeout, double rate);
-
-XBT_PUBLIC(msg_error_t)
-    MSG_task_receive_bounded(msg_task_t * task, const char *alias,double rate);
+XBT_PUBLIC(msg_error_t) MSG_task_receive_with_timeout_bounded(msg_task_t * task, const char *alias,  double timeout, double rate);
+XBT_PUBLIC(msg_error_t) MSG_task_receive_bounded(msg_task_t * task, const char *alias,double rate);

 #define MSG_task_recv_bounded(t,a,r) MSG_task_receive_bounded(t,a,r)
 
 XBT_PUBLIC(msg_comm_t) MSG_task_isend(msg_task_t task, const char *alias);
 XBT_PUBLIC(msg_comm_t) MSG_task_isend_bounded(msg_task_t task, const char *alias, double maxrate);
 #define MSG_task_recv_bounded(t,a,r) MSG_task_receive_bounded(t,a,r)
 
 XBT_PUBLIC(msg_comm_t) MSG_task_isend(msg_task_t task, const char *alias);
 XBT_PUBLIC(msg_comm_t) MSG_task_isend_bounded(msg_task_t task, const char *alias, double maxrate);

-XBT_PUBLIC(msg_comm_t) MSG_task_isend_with_matching(msg_task_t task,
-                                                    const char *alias,
-                                                    int (*match_fun)(void*,void*, smx_synchro_t),
-                                                    void *match_data);
+XBT_PUBLIC(msg_comm_t) MSG_task_isend_with_matching(msg_task_t task, const char *alias,
+    int (*match_fun)(void*,void*, smx_synchro_t), void *match_data);

 
 XBT_PUBLIC(void) MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup);
 XBT_PUBLIC(void) MSG_task_dsend_bounded(msg_task_t task, const char *alias, void_f_pvoid_t cleanup, double maxrate);
 
 XBT_PUBLIC(void) MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup);
 XBT_PUBLIC(void) MSG_task_dsend_bounded(msg_task_t task, const char *alias, void_f_pvoid_t cleanup, double maxrate);


@@ -460,33 +454,18 @@ XBT_PUBLIC(int) MSG_comm_test(msg_comm_t comm);
 XBT_PUBLIC(int) MSG_comm_testany(xbt_dynar_t comms);
 XBT_PUBLIC(void) MSG_comm_destroy(msg_comm_t comm);
 XBT_PUBLIC(msg_error_t) MSG_comm_wait(msg_comm_t comm, double timeout);
 XBT_PUBLIC(int) MSG_comm_testany(xbt_dynar_t comms);
 XBT_PUBLIC(void) MSG_comm_destroy(msg_comm_t comm);
 XBT_PUBLIC(msg_error_t) MSG_comm_wait(msg_comm_t comm, double timeout);

-XBT_PUBLIC(void) MSG_comm_waitall(msg_comm_t * comm, int nb_elem,
-                                  double timeout);
+XBT_PUBLIC(void) MSG_comm_waitall(msg_comm_t * comm, int nb_elem, double timeout);

 XBT_PUBLIC(int) MSG_comm_waitany(xbt_dynar_t comms);
 XBT_PUBLIC(msg_task_t) MSG_comm_get_task(msg_comm_t comm);
 XBT_PUBLIC(msg_error_t) MSG_comm_get_status(msg_comm_t comm);
 
 XBT_PUBLIC(int) MSG_task_listen(const char *alias);
 XBT_PUBLIC(int) MSG_comm_waitany(xbt_dynar_t comms);
 XBT_PUBLIC(msg_task_t) MSG_comm_get_task(msg_comm_t comm);
 XBT_PUBLIC(msg_error_t) MSG_comm_get_status(msg_comm_t comm);
 
 XBT_PUBLIC(int) MSG_task_listen(const char *alias);

-
-XBT_PUBLIC(int) MSG_task_listen_from_host(const char *alias,
-                                          msg_host_t host);
-
-XBT_PUBLIC(msg_error_t)
-    MSG_task_send_with_timeout(msg_task_t task, const char *alias,
-                           double timeout);
-
-XBT_PUBLIC(msg_error_t)
-    MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alias,
-                           double timeout, double maxrate);
-
-XBT_PUBLIC(msg_error_t)
-    MSG_task_send(msg_task_t task, const char *alias);
-
-XBT_PUBLIC(msg_error_t)
-    MSG_task_send_bounded(msg_task_t task, const char *alias, double rate);
-
+XBT_PUBLIC(int) MSG_task_listen_from_host(const char *alias, msg_host_t host);
+XBT_PUBLIC(msg_error_t) MSG_task_send_with_timeout(msg_task_t task, const char *alias, double timeout);
+XBT_PUBLIC(msg_error_t) MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alias, double timeout, double maxrate);
+XBT_PUBLIC(msg_error_t) MSG_task_send(msg_task_t task, const char *alias);
+XBT_PUBLIC(msg_error_t) MSG_task_send_bounded(msg_task_t task, const char *alias, double rate);

 XBT_PUBLIC(int) MSG_task_listen_from(const char *alias);
 XBT_PUBLIC(int) MSG_task_listen_from(const char *alias);

-

 XBT_PUBLIC(void) MSG_task_set_category (msg_task_t task, const char *category);
 XBT_PUBLIC(const char *) MSG_task_get_category (msg_task_t task);
 
 XBT_PUBLIC(void) MSG_task_set_category (msg_task_t task, const char *category);
 XBT_PUBLIC(const char *) MSG_task_get_category (msg_task_t task);
 

diff --git a/include/xbt/xbt_os_time.h b/include/xbt/xbt_os_time.h
index 36aac64..b9d9b46 100644 (file)
--- a/include/xbt/xbt_os_time.h
+++ b/include/xbt/xbt_os_time.h
@@ -15,9 +15,9 @@
 SG_BEGIN_DECL()
 
 /** @brief get time in seconds 
 SG_BEGIN_DECL()
 
 /** @brief get time in seconds 

-
-  * gives  the  number  of  seconds since the Epoch (00:00:00 UTC, January 1, 1970).
-  */
+ *
+ * gives  the  number  of  seconds since the Epoch (00:00:00 UTC, January 1, 1970).
+ */

 XBT_PUBLIC(double) xbt_os_time(void);
 XBT_PUBLIC(void) xbt_os_sleep(double sec);
 
 XBT_PUBLIC(double) xbt_os_time(void);
 XBT_PUBLIC(void) xbt_os_sleep(double sec);
 

diff --git a/src/simix/smx_network.cpp b/src/simix/smx_network.cpp
index 0832f20..dcdf42b 100644 (file)
--- a/src/simix/smx_network.cpp
+++ b/src/simix/smx_network.cpp
@@ -5,7 +5,7 @@
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "src/surf/surf_interface.hpp"
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "src/surf/surf_interface.hpp"

-#include "smx_private.h"
+#include "src/simix/smx_private.h"

 #include "xbt/log.h"
 #include "mc/mc.h"
 #include "src/mc/mc_replay.h"
 #include "xbt/log.h"
 #include "mc/mc.h"
 #include "src/mc/mc_replay.h"


@@ -432,29 +432,25 @@ void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_process_t receiver, sm
 }
 
 smx_synchro_t simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_process_t receiver, smx_rdv_t rdv,
 }
 
 smx_synchro_t simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_process_t receiver, smx_rdv_t rdv,

-                                  void *dst_buff, size_t *dst_buff_size,
-                                  int (*match_fun)(void *, void *, smx_synchro_t),
-                                  void (*copy_data_fun)(smx_synchro_t, void*, size_t),
-          void *data, double rate)
+    void *dst_buff, size_t *dst_buff_size,
+    int (*match_fun)(void *, void *, smx_synchro_t),
+    void (*copy_data_fun)(smx_synchro_t, void*, size_t),
+    void *data, double rate)

 {
 {

-  return SIMIX_comm_irecv(receiver, rdv, dst_buff, dst_buff_size,
-              match_fun, copy_data_fun, data, rate);
+  return SIMIX_comm_irecv(receiver, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);

 }
 
 }
 

-smx_synchro_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_rdv_t rdv,
-                              void *dst_buff, size_t *dst_buff_size,
-                              int (*match_fun)(void *, void *, smx_synchro_t),
-                              void (*copy_data_fun)(smx_synchro_t, void*, size_t), // used to copy data if not default one
-                              void *data, double rate)
+smx_synchro_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size,
+    int (*match_fun)(void *, void *, smx_synchro_t),
+    void (*copy_data_fun)(smx_synchro_t, void*, size_t), // used to copy data if not default one
+    void *data, double rate)

 {
   XBT_DEBUG("recv from %p %p", rdv, rdv->comm_fifo);
   smx_synchro_t this_synchro = SIMIX_comm_new(SIMIX_COMM_RECEIVE);
 
   smx_synchro_t other_synchro;
   //communication already done, get it inside the fifo of completed comms
 {
   XBT_DEBUG("recv from %p %p", rdv, rdv->comm_fifo);
   smx_synchro_t this_synchro = SIMIX_comm_new(SIMIX_COMM_RECEIVE);
 
   smx_synchro_t other_synchro;
   //communication already done, get it inside the fifo of completed comms

-  //permanent receive v1
-  //int already_received=0;
-  if(rdv->permanent_receiver && xbt_fifo_size(rdv->done_comm_fifo)!=0){
+  if (rdv->permanent_receiver && xbt_fifo_size(rdv->done_comm_fifo)!=0) {

 
     XBT_DEBUG("We have a comm that has probably already been received, trying to match it, to skip the communication");
     //find a match in the already received fifo
 
     XBT_DEBUG("We have a comm that has probably already been received, trying to match it, to skip the communication");
     //find a match in the already received fifo


@@ -464,21 +460,18 @@ smx_synchro_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_rdv_t rdv,
       XBT_DEBUG("We have messages in the permanent receive list, but not the one we are looking for, pushing request into fifo");
       other_synchro = this_synchro;
       SIMIX_rdv_push(rdv, this_synchro);
       XBT_DEBUG("We have messages in the permanent receive list, but not the one we are looking for, pushing request into fifo");
       other_synchro = this_synchro;
       SIMIX_rdv_push(rdv, this_synchro);

-    }else{
-      if(other_synchro->comm.surf_comm &&   SIMIX_comm_get_remains(other_synchro)==0.0)
-      {
+    } else {
+      if(other_synchro->comm.surf_comm && SIMIX_comm_get_remains(other_synchro)==0.0) {

         XBT_DEBUG("comm %p has been already sent, and is finished, destroy it",&(other_synchro->comm));
         other_synchro->state = SIMIX_DONE;
         other_synchro->comm.type = SIMIX_COMM_DONE;
         other_synchro->comm.rdv = NULL;
         XBT_DEBUG("comm %p has been already sent, and is finished, destroy it",&(other_synchro->comm));
         other_synchro->state = SIMIX_DONE;
         other_synchro->comm.type = SIMIX_COMM_DONE;
         other_synchro->comm.rdv = NULL;

-      }/*else{
-         XBT_DEBUG("Not yet finished, we have to wait %d", xbt_fifo_size(rdv->comm_fifo));
-         }*/
+      }

       other_synchro->comm.refcount--;
       SIMIX_comm_destroy(this_synchro);
       --smx_total_comms; // this creation was a pure waste
     }
       other_synchro->comm.refcount--;
       SIMIX_comm_destroy(this_synchro);
       --smx_total_comms; // this creation was a pure waste
     }

-  }else{
+  } else {

     /* Prepare a synchro describing us, so that it gets passed to the user-provided filter of other side */
 
     /* Look for communication synchro matching our needs. We also provide a description of
     /* Prepare a synchro describing us, so that it gets passed to the user-provided filter of other side */
 
     /* Look for communication synchro matching our needs. We also provide a description of


@@ -507,25 +500,18 @@ smx_synchro_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_rdv_t rdv,
   other_synchro->comm.dst_buff_size = dst_buff_size;
   other_synchro->comm.dst_data = data;
 
   other_synchro->comm.dst_buff_size = dst_buff_size;
   other_synchro->comm.dst_data = data;
 

-  if (rate != -1.0 &&
-      (other_synchro->comm.rate == -1.0 || rate < other_synchro->comm.rate))
+  if (rate != -1.0 && (other_synchro->comm.rate == -1.0 || rate < other_synchro->comm.rate))

     other_synchro->comm.rate = rate;
 
   other_synchro->comm.match_fun = match_fun;
   other_synchro->comm.copy_data_fun = copy_data_fun;
 
     other_synchro->comm.rate = rate;
 
   other_synchro->comm.match_fun = match_fun;
   other_synchro->comm.copy_data_fun = copy_data_fun;
 

-
-  /*if(already_received)//do the actual copy, because the first one after the comm didn't have all the info
-    SIMIX_comm_copy_data(other_synchro);*/
-
-

   if (MC_is_active() || MC_record_replay_is_active()) {
     other_synchro->state = SIMIX_RUNNING;
     return other_synchro;
   }
 
   SIMIX_comm_start(other_synchro);
   if (MC_is_active() || MC_record_replay_is_active()) {
     other_synchro->state = SIMIX_RUNNING;
     return other_synchro;
   }
 
   SIMIX_comm_start(other_synchro);

-  // }

   return other_synchro;
 }
 
   return other_synchro;
 }
 

diff --git a/teshsuite/msg/host_on_off_processes/host_on_off_processes.c b/teshsuite/msg/host_on_off_processes/host_on_off_processes.c
index c6e8222..2f480e5 100644 (file)
--- a/teshsuite/msg/host_on_off_processes/host_on_off_processes.c
+++ b/teshsuite/msg/host_on_off_processes/host_on_off_processes.c
@@ -11,8 +11,7 @@
 /* Create a log channel to have nice outputs. */
 #include "xbt/log.h"
 #include "xbt/asserts.h"
 /* Create a log channel to have nice outputs. */
 #include "xbt/log.h"
 #include "xbt/asserts.h"

-XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test,
-                             "Messages specific for this msg example");
+XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test, "Messages specific for this msg example");

 
 int test_launcher(int argc, char *argv[]);
 int process_daemon(int argc, char *argv[]);
 
 int test_launcher(int argc, char *argv[]);
 int process_daemon(int argc, char *argv[]);