X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3ff57286d588a0fe37cce5bc46383c4c49d9b956..cfb3987654b857620ba388fab9883a095debeb72:/src/kernel/activity/CommImpl.hpp diff --git a/src/kernel/activity/CommImpl.hpp b/src/kernel/activity/CommImpl.hpp index 2f8d42a908..f3d98399ca 100644 --- a/src/kernel/activity/CommImpl.hpp +++ b/src/kernel/activity/CommImpl.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2007-2021. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2007-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. */ @@ -8,35 +8,44 @@ #include "src/kernel/activity/ActivityImpl.hpp" #include "src/kernel/actor/ActorImpl.hpp" -#include "surf/surf.hpp" +#include "src/kernel/actor/CommObserver.hpp" +namespace simgrid::kernel::activity { -namespace simgrid { -namespace kernel { -namespace activity { +enum class CommImplType { SEND, RECEIVE }; + +using timeout_action_type = std::unique_ptr>; class XBT_PUBLIC CommImpl : public ActivityImpl_T { ~CommImpl() override; - void cleanup_surf(); - static void (*copy_data_callback_)(CommImpl*, void*, size_t); + static std::function copy_data_callback_; - double rate_ = 0.0; + double rate_ = -1.0; double size_ = 0.0; bool detached_ = false; /* If detached or not */ bool copied_ = false; /* whether the data were already copied */ - MailboxImpl* mbox_ = nullptr; /* Rendez-vous where the comm is queued */ + MailboxImpl* mbox_ = nullptr; /* Rendez-vous where the comm is queued. nullptr once the comm is matched with both a + sender and receiver */ + long mbox_id_ = -1; /* ID of the rendez-vous where the comm was first queued (for MC) */ s4u::Host* from_ = nullptr; /* Pre-determined only for direct host-to-host communications */ s4u::Host* to_ = nullptr; /* Otherwise, computed at start() time from the actors */ + CommImplType type_ = CommImplType::SEND; /* Type of the communication (SEND or RECEIVE) */ -public: - enum class Type { SEND, RECEIVE }; + static unsigned next_id_; // Next ID to be given (for MC) + const unsigned id_ = ++next_id_; // ID of this comm (for MC) -- 0 as an ID denotes "invalid/unknown comm" - static void set_copy_data_callback(void (*callback)(CommImpl*, void*, size_t)); +public: + CommImpl(); - explicit CommImpl(Type type) : type_(type) {} - CommImpl(s4u::Host* from, s4u::Host* to, double bytes); + static void set_copy_data_callback(const std::function& callback); + CommImpl& set_type(CommImplType type); + CommImplType get_type() const { return type_; } + CommImpl& set_source(s4u::Host* from); + s4u::Host* get_source() const { return from_; } + CommImpl& set_destination(s4u::Host* to); + s4u::Host* get_destination() const { return to_; } CommImpl& set_size(double size); CommImpl& set_src_buff(unsigned char* buff, size_t size); CommImpl& set_dst_buff(unsigned char* buff, size_t* size); @@ -46,34 +55,41 @@ public: double get_rate() const { return rate_; } MailboxImpl* get_mailbox() const { return mbox_; } - bool detached() const { return detached_; } + unsigned get_mailbox_id() const { return mbox_id_; } + unsigned get_id() const { return id_; } + bool is_detached() const { return detached_; } + bool is_assigned() const { return (to_ != nullptr && from_ != nullptr); } + std::vector get_traversed_links() const; void copy_data(); + static ActivityImplPtr isend(actor::CommIsendSimcall* observer); + static ActivityImplPtr irecv(actor::CommIrecvSimcall* observer); + + bool test(actor::ActorImpl* issuer) override; + void wait_for(actor::ActorImpl* issuer, double timeout) override; + static void wait_any_for(actor::ActorImpl* issuer, const std::vector& comms, double timeout); + CommImpl* start(); void suspend() override; void resume() override; void cancel() override; - void post() override; + void set_exception(actor::ActorImpl* issuer) override; void finish() override; - const Type type_ = Type::SEND; /* Type of the communication (SEND or RECEIVE) */ - -#if SIMGRID_HAVE_MC - MailboxImpl* mbox_cpy = nullptr; /* Copy of the rendez-vous where the comm is queued, MC needs it for DPOR - (comm.mbox set to nullptr when the communication is removed from the mailbox - (used as garbage collector)) */ -#endif - - void (*clean_fun)(void*) = nullptr; /* Function to clean the detached src_buf if something goes wrong */ - bool (*match_fun)(void*, void*, CommImpl*) = nullptr; /* Filter function used by the other side. It is used when + std::function clean_fun; /* Function to clean the detached src_buf if something goes wrong */ + std::function match_fun; /* Filter function used by the other side. It is used when looking if a given communication matches my needs. For that, myself must match the expectations of the other side, too. See */ - void (*copy_data_fun)(CommImpl*, void*, size_t) = nullptr; + std::function copy_data_fun; + + /* In stateful MC, we need to ignore some private memory that is not relevant to the application state */ + static void setup_mc(); + + /* Model actions */ + timeout_action_type src_timeout_{nullptr, [](resource::Action* a) { a->unref(); }}; /* timeout set by the sender */ + timeout_action_type dst_timeout_{nullptr, [](resource::Action* a) { a->unref(); }}; /* timeout set by the receiver */ - /* Surf action data */ - resource::Action* src_timeout_ = nullptr; /* Surf's actions to instrument the timeouts */ - resource::Action* dst_timeout_ = nullptr; /* Surf's actions to instrument the timeouts */ actor::ActorImplPtr src_actor_ = nullptr; actor::ActorImplPtr dst_actor_ = nullptr; @@ -82,12 +98,11 @@ expectations of the other side, too. See */ unsigned char* dst_buff_ = nullptr; size_t src_buff_size_ = 0; size_t* dst_buff_size_ = nullptr; + void* payload_ = nullptr; // If dst_buff_ is NULL, the default copy callback puts the data here void* src_data_ = nullptr; /* User data associated to the communication */ void* dst_data_ = nullptr; }; -} // namespace activity -} // namespace kernel -} // namespace simgrid +} // namespace simgrid::kernel::activity #endif