class XBT_PUBLIC Engine {
public:
/** Constructor, taking the command line parameters of your main function */
- Engine(int* argc, char** argv);
+ explicit Engine(int* argc, char** argv);
+ /** Currently, only one instance is allowed to exist. This is why you can't copy or move it */
+ Engine(const Engine&) = delete;
+ Engine(Engine&&) = delete;
~Engine();
/** Finalize the default engine and all its dependencies */
protected:
friend s4u::Host;
+ friend s4u::Link;
friend s4u::Storage;
friend kernel::routing::NetPoint;
friend kernel::routing::NetZoneImpl;
+ friend kernel::resource::LinkImpl;
void host_register(std::string name, simgrid::s4u::Host* host);
void host_unregister(std::string name);
+ void link_register(std::string name, simgrid::s4u::Link* link);
+ void link_unregister(std::string name);
void storage_register(std::string name, simgrid::s4u::Storage* storage);
void storage_unregister(std::string name);
void netpoint_register(simgrid::kernel::routing::NetPoint* card);
public:
size_t get_host_count();
std::vector<Host*> get_all_hosts();
+ std::vector<Host*> get_filtered_hosts(std::function<bool(Host*)> filter);
simgrid::s4u::Host* host_by_name(std::string name);
simgrid::s4u::Host* host_by_name_or_null(std::string name);
size_t get_link_count();
std::vector<Link*> get_all_links();
+ std::vector<Link*> get_filtered_links(std::function<bool(Link*)> filter);
+ simgrid::s4u::Link* link_by_name(std::string name);
+ simgrid::s4u::Link* link_by_name_or_null(std::string name);
+
+ size_t get_actor_count();
+ std::vector<ActorPtr> get_all_actors();
+ std::vector<ActorPtr> get_filtered_actors(std::function<bool(ActorPtr)> filter);
size_t get_storage_count();
std::vector<Storage*> get_all_storages();
simgrid::s4u::Storage* storage_by_name_or_null(std::string name);
std::vector<simgrid::kernel::routing::NetPoint*> get_all_netpoints();
+ simgrid::kernel::routing::NetPoint* netpoint_by_name_or_null(std::string name);
- /** @brief Retrieve the root netzone, containing all others */
- simgrid::s4u::NetZone* getNetRoot();
-
- simgrid::s4u::NetZone* getNetzoneByNameOrNull(const char* name);
+ simgrid::s4u::NetZone* get_netzone_root();
+ void set_netzone_root(s4u::NetZone* netzone);
- /** @brief Retrieves all netzones of the same type than the subtype of the whereto vector */
- template <class T> void getNetzoneByType(std::vector<T*> * whereto) { netzoneByTypeRecursive(getNetRoot(), whereto); }
+ simgrid::s4u::NetZone* netzone_by_name_or_null(const char* name);
- /** @brief Retrieve the netcard of the given name (or nullptr if not found) */
- simgrid::kernel::routing::NetPoint* getNetpointByNameOrNull(std::string name);
+ /** @brief Retrieves all netzones of the type indicated by the template argument */
+ template <class T> std::vector<T*> get_filtered_netzones()
+ {
+ std::vector<T*> res;
+ get_filtered_netzones_recursive(get_netzone_root(), &res);
+ return res;
+ }
/** Returns whether SimGrid was initialized yet -- mostly for internal use */
static bool is_initialized();
*/
void set_config(std::string str);
- simgrid::kernel::EngineImpl* pimpl;
-
private:
+ simgrid::kernel::EngineImpl* pimpl;
static s4u::Engine* instance_;
//////////////// Deprecated functions
return get_all_hosts();
}
XBT_ATTRIB_DEPRECATED_v323("Please use Engine::get_link_count()") size_t getLinkCount() { return get_link_count(); }
- XBT_ATTRIB_DEPRECATED_v323("Please use Engine::get_link_list()")
- XBT_ATTRIB_DEPRECATED_v322("Engine::getLinkList() is deprecated in favor of Engine::get_all_links(). Please "
- "switch before v3.22") void getLinkList(std::vector<Link*>* list);
+ XBT_ATTRIB_DEPRECATED_v322("Engine::getLinkList() is deprecated in favor of Engine::get_all_links(). Please "
+ "switch before v3.22") void getLinkList(std::vector<Link*>* list);
XBT_ATTRIB_DEPRECATED_v323("Please use Engine::get_link_list()") std::vector<Link*> getAllLinks()
{
return get_all_links();
XBT_ATTRIB_DEPRECATED_v323("Please use Engine::get_clock()") static double getClock() { return get_clock(); }
XBT_ATTRIB_DEPRECATED_v323("Please use Engine::get_all_netpoints()") void getNetpointList(
std::vector<simgrid::kernel::routing::NetPoint*>* list);
+ XBT_ATTRIB_DEPRECATED_v323("Please use Engine::netpoint_by_name_or_null()")
+ simgrid::kernel::routing::NetPoint* getNetpointByNameOrNull(std::string name)
+ {
+ return netpoint_by_name_or_null(name);
+ }
+ XBT_ATTRIB_DEPRECATED_v323("Please use Engine::get_netzone_root()") simgrid::s4u::NetZone* getNetRoot()
+ {
+ return get_netzone_root();
+ }
+ XBT_ATTRIB_DEPRECATED_v323(
+ "Please use Engine::netzone_by_name_or_null()") simgrid::s4u::NetZone* getNetzoneByNameOrNull(const char* name)
+ {
+ return netzone_by_name_or_null(name);
+ }
+ template <class T>
+ XBT_ATTRIB_DEPRECATED_v323("Please use Engine::filter_netzones_by_type()") void getNetzoneByType(
+ std::vector<T*>* whereto)
+ {
+ get_filtered_netzones_recursive(get_netzone_root(), whereto);
+ }
+
XBT_ATTRIB_DEPRECATED_v323("Please use Engine::get_instance()") static s4u::Engine* getInstance()
{
return get_instance();
* right before the actual simulation starts. */
extern XBT_PUBLIC xbt::signal<void()> on_platform_created;
-/** Callback fired when the platform is about to be created (ie, just before the xml file is parsed) */
+/** Callback fired when the platform is about to be created
+ * (ie, after any configuration change and just before the resource creation) */
extern XBT_PUBLIC xbt::signal<void()> on_platform_creation;
/** Callback fired when the main simulation loop ends, just before the end of Engine::run() */
/** Callback fired when the time cannot jump because of inter-actors deadlock */
extern XBT_PUBLIC xbt::signal<void(void)> on_deadlock;
-template <class T> XBT_PRIVATE void netzoneByTypeRecursive(s4u::NetZone* current, std::vector<T*>* whereto)
+template <class T> XBT_PRIVATE void get_filtered_netzones_recursive(s4u::NetZone* current, std::vector<T*>* whereto)
{
- for (auto const& elem : *(current->getChildren())) {
- netzoneByTypeRecursive(elem, whereto);
+ for (auto const& elem : *(current->get_children())) {
+ get_filtered_netzones_recursive(elem, whereto);
if (elem == dynamic_cast<T*>(elem))
whereto->push_back(dynamic_cast<T*>(elem));
}