-/* Copyright (c) 2004-2016. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
#include <xbt/ex.hpp>
+#include "src/msg/msg_private.h"
#include "src/simix/smx_private.h" /* MSG_task_listen looks inside the rdv directly. Not clean. */
-#include "msg_private.h"
-#include "mc/mc.h"
-#include "xbt/log.h"
-#include "xbt/sysdep.h"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_gos, msg, "Logging specific to MSG (gos)");
+SG_BEGIN_DECL()
+
/** \ingroup msg_task_usage
* \brief Executes a task and waits for its termination.
*
msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeout)
{
simdata_task_t simdata = task->simdata;
- simdata_process_t p_simdata = static_cast<simdata_process_t>(SIMIX_process_self_get_data());
e_smx_state_t comp_state;
msg_error_t status = MSG_OK;
TRACE_msg_task_execute_start(task);
- xbt_assert((!simdata->compute) && !task->simdata->isused, "This task is executed somewhere else. Go fix your code!");
+ xbt_assert((not simdata->compute) && not task->simdata->isused,
+ "This task is executed somewhere else. Go fix your code!");
XBT_DEBUG("Computing on %s", MSG_process_get_name(MSG_process_self()));
- if (simdata->flops_amount <= 0.0 && !simdata->host_nb) {
+ if (simdata->flops_amount <= 0.0 && not simdata->host_nb) {
TRACE_msg_task_execute_end(task);
return MSG_OK;
}
simcall_execution_start(task->name, simdata->flops_amount, simdata->priority, simdata->bound));
}
simcall_set_category(simdata->compute, task->category);
- p_simdata->waiting_action = simdata->compute;
comp_state = simcall_execution_wait(simdata->compute);
- p_simdata->waiting_action = nullptr;
simdata->setNotUsed();
XBT_DEBUG("Execution task '%s' finished in state %d", task->name, (int)comp_state);
simcall_process_sleep(nb_sec);
}
catch(xbt_ex& e) {
- switch (e.category) {
- case cancel_error:
+ if (e.category == cancel_error) {
XBT_DEBUG("According to the JAVA API, a sleep call should only deal with HostFailureException, I'm lost.");
// adsein: MSG_TASK_CANCELED is assigned when someone kills the process that made the sleep, this is not
// correct. For instance, when the node is turned off, the error should be MSG_HOST_FAILURE, which is by the way
// and did not change anythings at the C level.
// See comment in the jmsg_process.c file, function JNIEXPORT void JNICALL Java_org_simgrid_msg_Process_sleep(JNIEnv *env, jclass cls, jlong jmillis, jint jnanos)
status = MSG_TASK_CANCELED;
- break;
- default:
+ } else
throw;
- }
}
TRACE_msg_process_sleep_out(MSG_process_self());
/* Try to receive it by calling SIMIX network layer */
try {
- simcall_comm_recv(MSG_process_self(), mailbox->getImpl(), task, nullptr, nullptr, nullptr, nullptr, timeout, rate);
+ simcall_comm_recv(MSG_process_self()->getImpl(), mailbox->getImpl(), task, nullptr, nullptr, nullptr, nullptr, timeout, rate);
XBT_DEBUG("Got task %s from %s",(*task)->name,mailbox->name());
(*task)->simdata->setNotUsed();
}
void *match_data, void_f_pvoid_t cleanup, int detached)
{
simdata_task_t t_simdata = nullptr;
- msg_process_t myself = SIMIX_process_self();
+ msg_process_t myself = MSG_process_self();
simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::byName(alias);
int call_end = TRACE_msg_task_put_start(task);
/* Prepare the task to send */
t_simdata = task->simdata;
t_simdata->sender = myself;
- t_simdata->source = (static_cast<simdata_process_t>(SIMIX_process_self_get_data()))->m_host;
+ t_simdata->source = MSG_host_self();
t_simdata->setUsed();
t_simdata->comm = nullptr;
msg_global->sent_msg++;
/* Send it by calling SIMIX network layer */
- smx_activity_t act = simcall_comm_isend(myself, mailbox->getImpl(), t_simdata->bytes_amount, t_simdata->rate,
+ smx_activity_t act = simcall_comm_isend(myself->getImpl(), mailbox->getImpl(), t_simdata->bytes_amount, t_simdata->rate,
task, sizeof(void *), match_fun, cleanup, nullptr, match_data,detached);
t_simdata->comm = static_cast<simgrid::kernel::activity::Comm*>(act);
msg_comm_t comm = nullptr;
- if (! detached) {
+ if (not detached) {
comm = xbt_new0(s_msg_comm_t, 1);
comm->task_sent = task;
comm->task_received = nullptr;
comm->task_sent = nullptr;
comm->task_received = task;
comm->status = MSG_OK;
- comm->s_comm = simcall_comm_irecv(MSG_process_self(), mbox->getImpl(), task, nullptr, nullptr, nullptr, nullptr, rate);
+ comm->s_comm = simcall_comm_irecv(SIMIX_process_self(), mbox->getImpl(), task, nullptr, nullptr, nullptr, nullptr, rate);
return comm;
}
*/
void MSG_comm_waitall(msg_comm_t * comm, int nb_elem, double timeout)
{
- int i = 0;
- for (i = 0; i < nb_elem; i++) {
+ for (int i = 0; i < nb_elem; i++)
MSG_comm_wait(comm[i], timeout);
- }
}
/** \ingroup msg_task_usage
/**
* \brief This function is called by SIMIX in kernel mode to copy the data of a comm.
- * \param comm the comm
+ * \param synchro the comm
* \param buff the data copied
* \param buff_size size of the buffer
*/
// notify the user callback if any
if (msg_global->task_copy_callback) {
msg_task_t task = static_cast<msg_task_t>(buff);
- msg_global->task_copy_callback(task, comm->src_proc, comm->dst_proc);
+ msg_global->task_copy_callback(task, comm->src_proc->ciface(), comm->dst_proc->ciface());
}
}
msg_error_t ret = MSG_OK;
simdata_task_t t_simdata = nullptr;
msg_process_t process = MSG_process_self();
- simdata_process_t p_simdata = static_cast<simdata_process_t>(SIMIX_process_self_get_data());
simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::byName(alias);
- int call_end = TRACE_msg_task_put_start(task); //must be after CHECK_HOST()
+ int call_end = TRACE_msg_task_put_start(task);
/* Prepare the task to send */
t_simdata = task->simdata;
t_simdata->sender = process;
- t_simdata->source = (static_cast<simdata_process_t>(SIMIX_process_self_get_data())) ->m_host;
+ t_simdata->source = MSG_host_self();
t_simdata->setUsed();
t_simdata->comm = nullptr;
msg_global->sent_msg++;
- p_simdata->waiting_task = task;
-
/* Try to send it by calling SIMIX network layer */
try {
smx_activity_t comm = nullptr; /* MC needs the comm to be set to nullptr during the simix call */
t_simdata->setNotUsed();
}
- p_simdata->waiting_task = nullptr;
if (call_end)
TRACE_msg_task_put_end();
return ret;
int MSG_task_listen(const char *alias)
{
simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::byName(alias);
- return !mbox->empty() ||
- (mbox->getImpl()->permanent_receiver && !mbox->getImpl()->done_comm_queue.empty());
+ return mbox->listen() ? 1 : 0;
}
/** \ingroup msg_task_usage
simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::byName(alias);
simgrid::kernel::activity::Comm* comm = static_cast<simgrid::kernel::activity::Comm*>(mbox->front());
- if (!comm)
+ if (not comm)
return -1;
return MSG_process_get_PID( static_cast<msg_task_t>(comm->src_data)->simdata->sender );
return task->category;
}
-/**
- * \brief Returns the value of a given AS or router property
- *
- * \param asr the name of a router or AS
- * \param name a property name
- * \return value of a property (or nullptr if property not set)
- */
-const char *MSG_as_router_get_property_value(const char* asr, const char *name)
-{
- return static_cast<char*>(xbt_dict_get_or_null(MSG_as_router_get_properties(asr), name));
-}
-
-/**
- * \brief Returns a xbt_dict_t consisting of the list of properties assigned to
- * a the AS or router
- *
- * \param asr the name of a router or AS
- * \return a dict containing the properties
- */
-xbt_dict_t MSG_as_router_get_properties(const char* asr)
-{
- return (simcall_asr_get_properties(asr));
-}
-
-/**
- * \brief Change the value of a given AS or router
- *
- * \param asr the name of a router or AS
- * \param name a property name
- * \param value what to change the property to
- */
-void MSG_as_router_set_property_value(const char* asr, const char* name, char* value)
-{
- xbt_dict_set(MSG_as_router_get_properties(asr), name, value, nullptr);
-}
+SG_END_DECL()
