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);
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,
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)");
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.
*
/* 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);
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);
size_t src_buff_size;
int (*match_fun)(void *, void *);
void *data;
+ int detached;
smx_action_t result;
} comm_isend;
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;
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;
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;
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();
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;
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