X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b8df87e176f27b25534f27d7e240defa32ca35bc..HEAD:/src/s4u/s4u_Mailbox.cpp diff --git a/src/s4u/s4u_Mailbox.cpp b/src/s4u/s4u_Mailbox.cpp index 5262cdec6a..76613fbfa8 100644 --- a/src/s4u/s4u_Mailbox.cpp +++ b/src/s4u/s4u_Mailbox.cpp @@ -1,20 +1,20 @@ -/* Copyright (c) 2006-2019. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2006-2023. 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 "simgrid/s4u/Comm.hpp" -#include "simgrid/s4u/Mailbox.hpp" -#include "src/kernel/activity/MailboxImpl.hpp" #include +#include +#include + +#include "src/kernel/activity/MailboxImpl.hpp" XBT_LOG_EXTERNAL_CATEGORY(s4u); XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_channel, s4u, "S4U Communication Mailboxes"); -namespace simgrid { -namespace s4u { +namespace simgrid::s4u { -const simgrid::xbt::string& Mailbox::get_name() const +const std::string& Mailbox::get_name() const { return pimpl_->get_name(); } @@ -24,134 +24,141 @@ const char* Mailbox::get_cname() const return pimpl_->get_cname(); } -MailboxPtr Mailbox::by_name(std::string name) +Mailbox* Mailbox::by_name(const std::string& name) { - kernel::activity::MailboxImpl* mbox = kernel::activity::MailboxImpl::by_name_or_null(name); - if (mbox == nullptr) { - mbox = simix::simcall([name] { return kernel::activity::MailboxImpl::by_name_or_create(name); }); - } - return MailboxPtr(&mbox->piface_, true); + return Engine::get_instance()->mailbox_by_name_or_create(name); } -bool Mailbox::empty() +bool Mailbox::empty() const { - return pimpl_->comm_queue_.empty(); + return pimpl_->empty(); } -bool Mailbox::listen() +size_t Mailbox::size() const { - return not this->empty() || (pimpl_->permanent_receiver_ && not pimpl_->done_comm_queue_.empty()); + return pimpl_->size(); } -bool Mailbox::ready() +bool Mailbox::listen() const +{ + return not pimpl_->empty() || (pimpl_->is_permanent() && pimpl_->has_some_done_comm()); +} + +aid_t Mailbox::listen_from() const +{ + kernel::activity::CommImplPtr comm = front(); + if (comm && comm->src_actor_) + return comm->src_actor_->get_pid(); + else + return -1; +} + +bool Mailbox::ready() const { bool comm_ready = false; - if (not pimpl_->comm_queue_.empty()) { - comm_ready = pimpl_->comm_queue_.front()->state_ == SIMIX_DONE; - - } else if (pimpl_->permanent_receiver_ && not pimpl_->done_comm_queue_.empty()) { - comm_ready = pimpl_->done_comm_queue_.front()->state_ == SIMIX_DONE; + if (not pimpl_->empty()) { + comm_ready = pimpl_->front()->get_state() == kernel::activity::State::DONE; + + } else if (pimpl_->is_permanent() && pimpl_->has_some_done_comm()) { + comm_ready = pimpl_->done_front()->get_state() == kernel::activity::State::DONE; } return comm_ready; } -smx_activity_t Mailbox::front() +kernel::activity::CommImplPtr Mailbox::front() const { - return pimpl_->comm_queue_.empty() ? nullptr : pimpl_->comm_queue_.front(); + return pimpl_->empty() ? nullptr : pimpl_->front(); } void Mailbox::set_receiver(ActorPtr actor) { - simix::simcall([this, actor]() { this->pimpl_->set_receiver(actor); }); + kernel::actor::simcall_answered([this, actor]() { this->pimpl_->set_receiver(actor); }); } /** @brief get the receiver (process associated to the mailbox) */ -ActorPtr Mailbox::get_receiver() +ActorPtr Mailbox::get_receiver() const { - if (pimpl_->permanent_receiver_ == nullptr) + if (pimpl_->is_permanent()) return ActorPtr(); - return pimpl_->permanent_receiver_->iface(); + return pimpl_->get_permanent_receiver()->get_iface(); } CommPtr Mailbox::put_init() { - CommPtr res = CommPtr(new s4u::Comm()); - res->sender_ = SIMIX_process_self(); - res->mailbox_ = this; + CommPtr res(new Comm()); + res->sender_ = kernel::actor::ActorImpl::self(); + res->set_mailbox(this); return res; } -s4u::CommPtr Mailbox::put_init(void* data, uint64_t simulated_size_in_bytes) + +CommPtr Mailbox::put_init(void* payload, uint64_t simulated_size_in_bytes) { - s4u::CommPtr res = put_init(); - res->set_remaining(simulated_size_in_bytes); - res->src_buff_ = data; - res->src_buff_size_ = sizeof(void*); - return res; + return put_init()->set_payload_size(simulated_size_in_bytes)->set_src_data(payload)->set_src_data_size(sizeof(void*)); } -s4u::CommPtr Mailbox::put_async(void* payload, uint64_t simulated_size_in_bytes) + +CommPtr Mailbox::put_async(void* payload, uint64_t simulated_size_in_bytes) { xbt_assert(payload != nullptr, "You cannot send nullptr"); - s4u::CommPtr res = put_init(payload, simulated_size_in_bytes); + CommPtr res = put_init(payload, simulated_size_in_bytes); res->start(); return res; } + void Mailbox::put(void* payload, uint64_t simulated_size_in_bytes) { xbt_assert(payload != nullptr, "You cannot send nullptr"); - CommPtr c = put_init(); - c->set_remaining(simulated_size_in_bytes); - c->set_src_data(payload); - c->wait(); + put_init()->set_payload_size(simulated_size_in_bytes)->set_src_data(payload)->start()->wait(); } + /** Blocking send with timeout */ void Mailbox::put(void* payload, uint64_t simulated_size_in_bytes, double timeout) { xbt_assert(payload != nullptr, "You cannot send nullptr"); - CommPtr c = put_init(); - c->set_remaining(simulated_size_in_bytes); - c->set_src_data(payload); - // c->start() is optional. - c->wait_for(timeout); + put_init()->set_payload_size(simulated_size_in_bytes)->set_src_data(payload)->start()->wait_for(timeout); } -s4u::CommPtr Mailbox::get_init() +CommPtr Mailbox::get_init() { - CommPtr res = CommPtr(new s4u::Comm()); - res->receiver_ = SIMIX_process_self(); - res->mailbox_ = this; + auto res = CommPtr(new Comm())->set_mailbox(this); + res->receiver_ = kernel::actor::ActorImpl::self(); return res; } -s4u::CommPtr Mailbox::get_async(void** data) + +CommPtr Mailbox::get_async() { - s4u::CommPtr res = get_init(); - res->set_dst_data(data, sizeof(*data)); + CommPtr res = get_init()->set_dst_data(nullptr, sizeof(void*)); res->start(); return res; } -void* Mailbox::get() +kernel::activity::ActivityImplPtr +Mailbox::iprobe(int type, const std::function& match_fun, void* data) { - void* res = nullptr; - CommPtr c = get_init(); - c->set_dst_data(&res, sizeof(res)); - c->wait(); - return res; + return kernel::actor::simcall_answered( + [this, type, &match_fun, data] { return pimpl_->iprobe(type, match_fun, data); }); } -void* Mailbox::get(double timeout) + +void Mailbox::clear() { - void* res = nullptr; - CommPtr c = get_init(); - c->set_dst_data(&res, sizeof(res)); - c->wait_for(timeout); - return res; + kernel::actor::simcall_answered([this]() { this->pimpl_->clear(true); }); } -} // namespace s4u -} // namespace simgrid + +} // namespace simgrid::s4u /* **************************** Public C interface *************************** */ +sg_mailbox_t sg_mailbox_by_name(const char* alias) +{ + return simgrid::s4u::Mailbox::by_name(alias); +} + +const char* sg_mailbox_get_name(const_sg_mailbox_t mailbox) +{ + return mailbox->get_cname(); +} + /** @brief Set the mailbox to receive in asynchronous mode * * All messages sent to this mailbox will be transferred to the receiver without waiting for the receive call. @@ -175,3 +182,34 @@ int sg_mailbox_listen(const char* alias) { return simgrid::s4u::Mailbox::by_name(alias)->listen() ? 1 : 0; } + +void* sg_mailbox_get(sg_mailbox_t mailbox) +{ + return mailbox->get(); +} + +sg_comm_t sg_mailbox_get_async(sg_mailbox_t mailbox, void** data) +{ + auto comm = mailbox->get_async(data); + comm->add_ref(); + return comm.get(); +} + +void sg_mailbox_put(sg_mailbox_t mailbox, void* payload, long simulated_size_in_bytes) +{ + mailbox->put(payload, simulated_size_in_bytes); +} + +sg_comm_t sg_mailbox_put_async(sg_mailbox_t mailbox, void* payload, long simulated_size_in_bytes) +{ + auto comm = mailbox->put_async(payload, simulated_size_in_bytes); + comm->add_ref(); + return comm.get(); +} + +sg_comm_t sg_mailbox_put_init(sg_mailbox_t mailbox, void* payload, long simulated_size_in_bytes) +{ + auto comm = mailbox->put_init(payload, simulated_size_in_bytes); + comm->add_ref(); + return comm.get(); +}