From: cristianrosa <cristianrosa@48e7efb5-ca39-0410-a469-dd3cf9ba447f>
Date: Mon, 31 Jan 2011 13:24:36 +0000 (+0000)
Subject: Add MSG_task_dsend function to MSG.
X-Git-Tag: v3.6_beta2~400
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/31b7fa457f9267af8eda2eee06aae74dd78eb412

Add MSG_task_dsend function to MSG.
MSG_task_dsend performs a best effort asynchronous send or dettached send.

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@9529 48e7efb5-ca39-0410-a469-dd3cf9ba447f
---

diff --git a/include/msg/msg.h b/include/msg/msg.h
index 48c42b0ead..6764b1a392 100644
--- a/include/msg/msg.h
+++ b/include/msg/msg.h
@@ -178,6 +178,7 @@ XBT_PUBLIC(MSG_error_t)
     MSG_task_receive(m_task_t * task, const char *alias);
 
 XBT_PUBLIC(msg_comm_t) MSG_task_isend(m_task_t task, const char *alias);
+XBT_PUBLIC(void) MSG_task_dsend(m_task_t task, const char *alias);
 XBT_PUBLIC(msg_comm_t) MSG_task_irecv(m_task_t * task, const char *alias);
 XBT_PUBLIC(int) MSG_comm_test(msg_comm_t comm);
 XBT_PUBLIC(int) MSG_comm_testany(xbt_dynar_t comms);
diff --git a/include/simix/simix.h b/include/simix/simix.h
index 956902ec31..034000910d 100644
--- a/include/simix/simix.h
+++ b/include/simix/simix.h
@@ -161,7 +161,7 @@ XBT_PUBLIC(smx_action_t) SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size,
                                            double rate, void *src_buff,
                                            size_t src_buff_size,
                                            int (*match_fun)(void *, void *),
-                                           void *data);
+                                           void *data, int detached);
 
 XBT_PUBLIC(smx_action_t) SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff,
                                            size_t * dst_buff_size,
diff --git a/src/gras/Msg/sg_msg.c b/src/gras/Msg/sg_msg.c
index b2e4dfd1da..06bebc5ca7 100644
--- a/src/gras/Msg/sg_msg.c
+++ b/src/gras/Msg/sg_msg.c
@@ -241,7 +241,7 @@ void gras_msg_send_ext(gras_socket_t sock,
                                                 payload, msg->payl);
   }
 
-  comm = SIMIX_req_comm_isend(target_rdv, whole_payload_size, -1, &msg, sizeof(void *), NULL, msg);
+  comm = SIMIX_req_comm_isend(target_rdv, whole_payload_size, -1, &msg, sizeof(void *), NULL, msg, 0);
   SIMIX_req_comm_wait(comm, -1);
 
   VERB0("Message sent (and received)");
diff --git a/src/msg/gos.c b/src/msg/gos.c
index e581ab09f9..9ab4dc018f 100644
--- a/src/msg/gos.c
+++ b/src/msg/gos.c
@@ -407,12 +407,53 @@ msg_comm_t MSG_task_isend(m_task_t task, const char *alias)
   comm->status = MSG_OK;
   comm->s_comm =
     SIMIX_req_comm_isend(mailbox, t_simdata->message_size,
-                         t_simdata->rate, task, sizeof(void *), NULL, NULL);
+                         t_simdata->rate, task, sizeof(void *), NULL, NULL, 0);
   t_simdata->comm = comm->s_comm; /* FIXME: is the field t_simdata->comm still useful? */
 
   return comm;
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Sends a task on a mailbox.
+ *
+ * This is a non blocking detached send function.
+ * Think of it as a best effort send. The communication
+ * object will be destroyed by the receiver (if any).
+ *
+ * \param task a #m_task_t to send on another location.
+ * \param alias name of the mailbox to sent the task to
+ */
+void MSG_task_dsend(m_task_t task, const char *alias)
+{
+  simdata_task_t t_simdata = NULL;
+  m_process_t process = MSG_process_self();
+  msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
+
+  CHECK_HOST();
+
+  /* FIXME: these functions are not traceable */
+
+  /* Prepare the task to send */
+  t_simdata = task->simdata;
+  t_simdata->sender = process;
+  t_simdata->source = MSG_host_self();
+
+  xbt_assert0(t_simdata->isused == 0,
+              "This task is still being used somewhere else. You cannot send it now. Go fix your code!");
+
+  t_simdata->isused = 1;
+  msg_global->sent_msg++;
+
+  /* Send it by calling SIMIX network layer */
+  msg_comm_t comm = xbt_new0(s_msg_comm_t, 1);
+  comm->task_sent = task;
+  comm->task_received = NULL;
+  comm->status = MSG_OK;
+    SIMIX_req_comm_isend(mailbox, t_simdata->message_size,
+                         t_simdata->rate, task, sizeof(void *), NULL, NULL, 1);
+    /*t_simdata->comm = comm->s_comm;  FIXME: is the field t_simdata->comm still useful? */
+}
+
 /** \ingroup msg_gos_functions
  * \brief Starts listening for receiving a task from an asynchronous communication.
  *
diff --git a/src/msg/msg_mailbox.c b/src/msg/msg_mailbox.c
index 3aa3a90553..07e19c4534 100644
--- a/src/msg/msg_mailbox.c
+++ b/src/msg/msg_mailbox.c
@@ -164,7 +164,7 @@ MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task,
   /* Try to send it by calling SIMIX network layer */
   TRY {
     comm = SIMIX_req_comm_isend(mailbox, t_simdata->message_size,
-             t_simdata->rate, task, sizeof(void *), NULL, NULL);
+             t_simdata->rate, task, sizeof(void *), NULL, NULL, 0);
     t_simdata->comm = comm;
 #ifdef HAVE_TRACING
     SIMIX_req_set_category(comm, task->category);
diff --git a/src/simix/network_private.h b/src/simix/network_private.h
index 8d65b75890..2f68f85e9d 100644
--- a/src/simix/network_private.h
+++ b/src/simix/network_private.h
@@ -32,7 +32,8 @@ smx_action_t SIMIX_rdv_get_head(smx_rdv_t rdv);
 smx_action_t SIMIX_comm_isend(smx_process_t src_proc, smx_rdv_t rdv,
                               double task_size, double rate,
                               void *src_buff, size_t src_buff_size,
-                              int (*)(void *, void *), void *data);
+                              int (*)(void *, void *), void *data,
+                              int detached);
 smx_action_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_rdv_t rdv,
                               void *dst_buff, size_t *dst_buff_size,
                               int (*)(void *, void *), void *data);
diff --git a/src/simix/smurf_private.h b/src/simix/smurf_private.h
index 972c6bc392..f7d17fc682 100644
--- a/src/simix/smurf_private.h
+++ b/src/simix/smurf_private.h
@@ -313,6 +313,7 @@ typedef struct s_smx_req {
       size_t src_buff_size;
       int (*match_fun)(void *, void *);
       void *data;
+      int detached;
       smx_action_t result;
     } comm_isend;
 
diff --git a/src/simix/smx_network.c b/src/simix/smx_network.c
index d1c83d3f07..11b84c6d64 100644
--- a/src/simix/smx_network.c
+++ b/src/simix/smx_network.c
@@ -246,7 +246,8 @@ void SIMIX_comm_destroy_internal_actions(smx_action_t action)
 smx_action_t SIMIX_comm_isend(smx_process_t src_proc, smx_rdv_t rdv,
                               double task_size, double rate,
                               void *src_buff, size_t src_buff_size,
-                              int (*match_fun)(void *, void *), void *data)
+                              int (*match_fun)(void *, void *), void *data,
+                              int detached)
 {
   smx_action_t action;
 
@@ -262,6 +263,11 @@ smx_action_t SIMIX_comm_isend(smx_process_t src_proc, smx_rdv_t rdv,
     action->comm.type = SIMIX_COMM_READY;
   }
 
+  /* If the communication action is detached then decrease the refcount
+   * by one, so it will be eliminated by the receivers destroy call */
+  if(detached)
+    action->comm.refcount--;
+
   /* Setup the communication request */
   action->comm.src_proc = src_proc;
   action->comm.task_size = task_size;
diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c
index bfc0443fb0..139d06bd97 100644
--- a/src/simix/smx_smurf.c
+++ b/src/simix/smx_smurf.c
@@ -100,7 +100,8 @@ void SIMIX_request_pre(smx_req_t req, int value)
           req->comm_isend.src_buff,
           req->comm_isend.src_buff_size,
           req->comm_isend.match_fun,
-          req->comm_isend.data);
+          req->comm_isend.data,
+          req->comm_isend.detached);
       SIMIX_request_answer(req);
       break;
 
diff --git a/src/simix/smx_user.c b/src/simix/smx_user.c
index c426229bf1..309624688c 100644
--- a/src/simix/smx_user.c
+++ b/src/simix/smx_user.c
@@ -618,7 +618,8 @@ smx_action_t SIMIX_req_rdv_get_head(smx_rdv_t rdv)
 
 smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate,
                               void *src_buff, size_t src_buff_size,
-                              int (*match_fun)(void *, void *), void *data)
+                              int (*match_fun)(void *, void *), void *data,
+                              int detached)
 {
   smx_req_t req = SIMIX_req_mine();
 
@@ -632,6 +633,7 @@ smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate,
   req->comm_isend.src_buff_size = src_buff_size;
   req->comm_isend.match_fun = match_fun;
   req->comm_isend.data = data;
+  req->comm_isend.detached = detached;
 
   SIMIX_request_push();
   return req->comm_isend.result;
diff --git a/src/smpi/smpi_base.c b/src/smpi/smpi_base.c
index 6822762096..8bb4d4f093 100644
--- a/src/smpi/smpi_base.c
+++ b/src/smpi/smpi_base.c
@@ -99,7 +99,7 @@ void smpi_mpi_start(MPI_Request request)
     print_request("New send", request);
     mailbox = smpi_process_remote_mailbox(request->dst);
     request->action = SIMIX_req_comm_isend(mailbox, request->size, -1.0,
-                                           request->buf, request->size, &match_send, request);
+                                           request->buf, request->size, &match_send, request, 0);
 #ifdef HAVE_TRACING
     SIMIX_req_set_category (request->action, TRACE_internal_smpi_get_category());
 #endif