X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/166ad11130482e81d2c3e860ab6c61e972a4cdf6..20ec61117d07aac36be57b81054710603f2656ce:/src/kernel/activity/MailboxImpl.cpp diff --git a/src/kernel/activity/MailboxImpl.cpp b/src/kernel/activity/MailboxImpl.cpp index 81324ccaac..88b2a08a13 100644 --- a/src/kernel/activity/MailboxImpl.cpp +++ b/src/kernel/activity/MailboxImpl.cpp @@ -1,82 +1,154 @@ -/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2007-2022. 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 "src/kernel/activity/MailboxImpl.hpp" - +#include "simgrid/msg.h" #include "src/kernel/activity/CommImpl.hpp" -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_mailbox, simix, "Mailbox implementation"); - -static xbt_dict_t mailboxes = xbt_dict_new_homogeneous([](void* data) { - delete static_cast(data); -}); +#include -void SIMIX_mailbox_exit() -{ - xbt_dict_free(&mailboxes); -} +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ker_mailbox, kernel, "Mailbox implementation"); /******************************************************************************/ /* Rendez-Vous Points */ /******************************************************************************/ -namespace simgrid { -namespace kernel { -namespace activity { -/** @brief Returns the mailbox of that name, or nullptr */ -MailboxImpl* MailboxImpl::byNameOrNull(const char* name) -{ - return static_cast(xbt_dict_get_or_null(mailboxes, name)); -} -/** @brief Returns the mailbox of that name, newly created on need */ -MailboxImpl* MailboxImpl::byNameOrCreate(const char* name) +namespace simgrid::kernel::activity { + +unsigned MailboxImpl::next_id_ = 0; + +MailboxImpl::~MailboxImpl() { - xbt_assert(name, "Mailboxes must have a name"); - /* two processes may have pushed the same mbox_create simcall at the same time */ - smx_mailbox_t mbox = static_cast(xbt_dict_get_or_null(mailboxes, name)); - if (not mbox) { - mbox = new MailboxImpl(name); - XBT_DEBUG("Creating a mailbox at %p with name %s", mbox, name); - xbt_dict_set(mailboxes, mbox->name_, mbox, nullptr); - } - return mbox; + clear(); + set_receiver(nullptr); } + /** @brief set the receiver of the mailbox to allow eager sends - * \param actor The receiving dude + * @param actor The receiving dude */ -void MailboxImpl::setReceiver(s4u::ActorPtr actor) +void MailboxImpl::set_receiver(s4u::ActorPtr actor) { - this->permanent_receiver = actor.get()->getImpl(); + if (this->permanent_receiver_) { + std::vector& mboxes = this->permanent_receiver_->mailboxes_; + mboxes.erase(std::remove(mboxes.begin(), mboxes.end(), this), mboxes.end()); + } + + if (actor != nullptr) + this->permanent_receiver_ = actor->get_impl(); + else + this->permanent_receiver_ = nullptr; } /** @brief Pushes a communication activity into a mailbox * @param comm What to add */ -void MailboxImpl::push(activity::CommImplPtr comm) +void MailboxImpl::push(CommImplPtr comm) { - comm->mbox = this; - this->comm_queue.push_back(std::move(comm)); + comm->set_mailbox(this); + this->comm_queue_.push_back(std::move(comm)); } /** @brief Removes a communication activity from a mailbox - * @param activity What to remove + * @param comm What to remove */ -void MailboxImpl::remove(smx_activity_t activity) +void MailboxImpl::remove(const CommImplPtr& comm) { - simgrid::kernel::activity::CommImplPtr comm = - boost::static_pointer_cast(activity); + xbt_assert(comm->get_mailbox() == this, "Comm %p is in mailbox %s, not mailbox %s", comm.get(), + (comm->get_mailbox() ? comm->get_mailbox()->get_cname() : "(null)"), this->get_cname()); - xbt_assert(comm->mbox == this, "Comm %p is in mailbox %s, not mailbox %s", comm, - (comm->mbox ? comm->mbox->name_ : "(null)"), this->name_); - comm->mbox = nullptr; - for (auto it = this->comm_queue.begin(); it != this->comm_queue.end(); it++) + comm->set_mailbox(nullptr); + for (auto it = this->comm_queue_.begin(); it != this->comm_queue_.end(); it++) if (*it == comm) { - this->comm_queue.erase(it); + this->comm_queue_.erase(it); return; } - xbt_die("Comm %p not found in mailbox %s", comm, this->name_); + xbt_die("Comm %p not found in mailbox %s", comm.get(), this->get_cname()); } + +/** @brief Removes all communication activities from a mailbox + */ +void MailboxImpl::clear() +{ + // CommImpl::cancel() will remove the comm from the mailbox.. + for (auto comm : done_comm_queue_) { + comm->cancel(); + comm->set_state(State::FAILED); + comm->post(); + } + done_comm_queue_.clear(); + + while (not comm_queue_.empty()) { + auto comm = comm_queue_.back(); + if (comm->get_state() == State::WAITING && not comm->is_detached()) { + comm->cancel(); + comm->set_state(State::FAILED); + comm->post(); + } else + comm_queue_.pop_back(); + } + xbt_assert(comm_queue_.empty() && done_comm_queue_.empty()); } + +CommImplPtr MailboxImpl::iprobe(int type, const std::function& match_fun, void* data) +{ + XBT_DEBUG("iprobe from %p %p", this, &comm_queue_); + + CommImplPtr this_comm(new CommImpl); + CommImplType other_type; + if (type == 1) { + this_comm->set_type(CommImplType::SEND); + other_type = CommImplType::RECEIVE; + } else { + this_comm->set_type(CommImplType::RECEIVE); + other_type = CommImplType::SEND; + } + CommImplPtr other_comm = nullptr; + if (permanent_receiver_ != nullptr && not done_comm_queue_.empty()) { + XBT_DEBUG("first check in the permanent recv mailbox, to see if we already got something"); + other_comm = find_matching_comm(other_type, match_fun, data, this_comm, /*done*/ true, /*remove_matching*/ false); + } + if (not other_comm) { + XBT_DEBUG("check if we have more luck in the normal mailbox"); + other_comm = find_matching_comm(other_type, match_fun, data, this_comm, /*done*/ false, /*remove_matching*/ false); + } + + return other_comm; } + +/** + * @brief Checks if there is a communication activity queued in comm_queue_ matching our needs + * @param type The type of communication we are looking for (comm_send, comm_recv) + * @param match_fun the function to apply + * @param this_user_data additional parameter to the match_fun + * @param my_synchro what to compare against + * @param remove_matching whether or not to clean the found object from the queue + * @return The communication activity if found, nullptr otherwise + */ +CommImplPtr MailboxImpl::find_matching_comm(CommImplType type, + const std::function& match_fun, + void* this_user_data, const CommImplPtr& my_synchro, bool done, + bool remove_matching) +{ + auto& comm_queue = done ? done_comm_queue_ : comm_queue_; + + auto iter = std::find_if( + comm_queue.begin(), comm_queue.end(), [&type, &match_fun, &this_user_data, &my_synchro](const CommImplPtr& comm) { + void* other_user_data = (comm->get_type() == CommImplType::SEND ? comm->src_data_ : comm->dst_data_); + return (comm->get_type() == type && (not match_fun || match_fun(this_user_data, other_user_data, comm.get())) && + (not comm->match_fun || comm->match_fun(other_user_data, this_user_data, my_synchro.get()))); + }); + if (iter == comm_queue.end()) { + XBT_DEBUG("No matching communication synchro found"); + return nullptr; + } + + const CommImplPtr& comm = *iter; + XBT_DEBUG("Found a matching communication synchro %p", comm.get()); + comm->set_mailbox(nullptr); + CommImplPtr comm_cpy = comm; + if (remove_matching) + comm_queue.erase(iter); + return comm_cpy; } +} // namespace simgrid::kernel::activity