.def_static("create_empty_zone", &simgrid::s4u::create_empty_zone, "Creates a zone of type Empty")
.def_static("create_wifi_zone", &simgrid::s4u::create_wifi_zone, "Creates a zone of type Wi-Fi")
.def("add_route",
- py::overload_cast<simgrid::kernel::routing::NetPoint*, simgrid::kernel::routing::NetPoint*,
- simgrid::kernel::routing::NetPoint*, simgrid::kernel::routing::NetPoint*,
- const std::vector<simgrid::s4u::LinkInRoute>&, bool>(&simgrid::s4u::NetZone::add_route),
- "Add a route between 2 netpoints")
+ [](simgrid::s4u::NetZone* self, simgrid::kernel::routing::NetPoint* src,
+ simgrid::kernel::routing::NetPoint* dst, simgrid::kernel::routing::NetPoint* gw_src,
+ simgrid::kernel::routing::NetPoint* gw_dst, const std::vector<simgrid::s4u::LinkInRoute>& links,
+ bool symmetrical) {
+ PyErr_WarnEx(PyExc_DeprecationWarning, // XBT_ATTRIB_DEPRECATED_v336. Once removed, uncomment the
+ // deprecation of the AddRoute function in C++
+ "Please call add_route either from Host to Host or NetZone to NetZone. This call will be "
+ "removed after SimGrid v3.35.",
+ 1);
+ self->add_route(src, dst, gw_src, gw_dst, links, symmetrical);
+ })
.def("add_route",
py::overload_cast<const simgrid::s4u::Host*, const simgrid::s4u::Host*,
const std::vector<simgrid::s4u::LinkInRoute>&, bool>(&simgrid::s4u::NetZone::add_route),
- "Add a route between 2 netpoints")
+ "Add a route between 2 hosts")
.def("add_route",
py::overload_cast<const simgrid::s4u::Host*, const simgrid::s4u::Host*,
const std::vector<const simgrid::s4u::Link*>&>(&simgrid::s4u::NetZone::add_route),
- "Add a route between 2 netpoints")
+ "Add a route between 2 hosts")
+ .def("add_route",
+ py::overload_cast<const simgrid::s4u::NetZone*, const simgrid::s4u::NetZone*,
+ const std::vector<simgrid::s4u::LinkInRoute>&, bool>(&simgrid::s4u::NetZone::add_route),
+ "Add a route between 2 netzones. The gateway of each zone gets used.")
+ .def("add_route",
+ py::overload_cast<const simgrid::s4u::NetZone*, const simgrid::s4u::NetZone*,
+ const std::vector<const simgrid::s4u::Link*>&>(&simgrid::s4u::NetZone::add_route),
+ "Add a route between 2 netzones. The gateway of each zone gets used.")
.def("create_host", py::overload_cast<const std::string&, double>(&simgrid::s4u::NetZone::create_host),
"Creates a host")
.def("create_host",
.def("create_router", &simgrid::s4u::NetZone::create_router, "Create a router")
.def("set_parent", &simgrid::s4u::NetZone::set_parent, "Set the parent of this zone")
.def("set_property", &simgrid::s4u::NetZone::set_property, "Add a property to this zone")
+ .def("set_gateway", py::overload_cast<const simgrid::s4u::Host*>(&simgrid::s4u::NetZone::set_gateway),
+ "Specify the gateway of this zone, to be used for inter-zone routes")
+ .def("set_gateway", py::overload_cast<simgrid::kernel::routing::NetPoint*>(&simgrid::s4u::NetZone::set_gateway),
+ "Specify the gateway of this zone, to be used for inter-zone routes")
.def_property_readonly("netpoint", &simgrid::s4u::NetZone::get_netpoint,
"Retrieve the netpoint associated to this zone")
.def("seal", &simgrid::s4u::NetZone::seal, "Seal this NetZone")
/* Class ClusterCallbacks */
py::class_<simgrid::s4u::ClusterCallbacks>(m, "ClusterCallbacks", "Callbacks used to create cluster zones")
- .def(py::init<const std::function<simgrid::s4u::ClusterCallbacks::ClusterNetPointCb>&,
+ .def(py::init<const std::function<simgrid::s4u::ClusterCallbacks::ClusterNetZoneCb>&,
const std::function<simgrid::s4u::ClusterCallbacks::ClusterLinkCb>&,
const std::function<simgrid::s4u::ClusterCallbacks::ClusterLinkCb>&>());
py::enum_<simgrid::s4u::Host::SharingPolicy>(host, "SharingPolicy")
.value("NONLINEAR", simgrid::s4u::Host::SharingPolicy::NONLINEAR)
- .value("LINEAR", simgrid::s4u::Host::SharingPolicy::LINEAR)
- .export_values();
+ .value("LINEAR", simgrid::s4u::Host::SharingPolicy::LINEAR);
/* Class Disk */
py::class_<simgrid::s4u::Disk, std::unique_ptr<simgrid::s4u::Disk, py::nodelete>> disk(
"Textual representation of the Disk");
py::enum_<simgrid::s4u::Disk::SharingPolicy>(disk, "SharingPolicy")
.value("NONLINEAR", simgrid::s4u::Disk::SharingPolicy::NONLINEAR)
- .value("LINEAR", simgrid::s4u::Disk::SharingPolicy::LINEAR)
- .export_values();
+ .value("LINEAR", simgrid::s4u::Disk::SharingPolicy::LINEAR);
py::enum_<simgrid::s4u::Disk::Operation>(disk, "Operation")
.value("READ", simgrid::s4u::Disk::Operation::READ)
.value("WRITE", simgrid::s4u::Disk::Operation::WRITE)
- .value("READWRITE", simgrid::s4u::Disk::Operation::READWRITE)
- .export_values();
+ .value("READWRITE", simgrid::s4u::Disk::Operation::READWRITE);
/* Class NetPoint */
py::class_<simgrid::kernel::routing::NetPoint, std::unique_ptr<simgrid::kernel::routing::NetPoint, py::nodelete>>
"__repr__", [](const Link* l) { return "Link(" + l->get_name() + ")"; },
"Textual representation of the Link");
py::enum_<Link::SharingPolicy>(link, "SharingPolicy")
- .value("NONLINEAR", Link::SharingPolicy::NONLINEAR)
- .value("WIFI", Link::SharingPolicy::WIFI)
- .value("SPLITDUPLEX", Link::SharingPolicy::SPLITDUPLEX)
- .value("SHARED", Link::SharingPolicy::SHARED)
- .value("FATPIPE", Link::SharingPolicy::FATPIPE)
- .export_values();
+ .value("NONLINEAR", Link::SharingPolicy::NONLINEAR,
+ "This policy takes a callback that specifies the maximal capacity as a function of the number of usage. "
+ "See the examples with 'degradation' in their name.")
+ .value("WIFI", Link::SharingPolicy::WIFI, "Pseudo-sharing policy requesting wifi-specific sharing.")
+ .value("SPLITDUPLEX", Link::SharingPolicy::SPLITDUPLEX,
+ "Each link is split in 2, UP and DOWN, one per direction. These links are SHARED.")
+ .value("SHARED", Link::SharingPolicy::SHARED,
+ "The bandwidth is shared between all comms using that link, regardless of their direction.")
+ .value("FATPIPE", Link::SharingPolicy::FATPIPE,
+ "Each comm can use the link fully, with no sharing (only a maximum). This is intended to represent the "
+ "backbone links that cannot be saturated by concurrent links, but have a maximal bandwidth.");
/* Class LinkInRoute */
py::class_<simgrid::s4u::LinkInRoute> linkinroute(m, "LinkInRoute", "Abstraction to add link in routes");
py::enum_<simgrid::s4u::LinkInRoute::Direction>(linkinroute, "Direction")
.value("UP", simgrid::s4u::LinkInRoute::Direction::UP)
.value("DOWN", simgrid::s4u::LinkInRoute::Direction::DOWN)
- .value("NONE", simgrid::s4u::LinkInRoute::Direction::NONE)
- .export_values();
+ .value("NONE", simgrid::s4u::LinkInRoute::Direction::NONE);
/* Class Split-Duplex Link */
py::class_<simgrid::s4u::SplitDuplexLink, Link, std::unique_ptr<simgrid::s4u::SplitDuplexLink, py::nodelete>>(
py::class_<Mutex, MutexPtr>(m, "Mutex",
"A classical mutex, but blocking in the simulation world."
"See the C++ documentation for details.")
- .def(py::init<>(&Mutex::create), py::call_guard<py::gil_scoped_release>(), "Mutex constructor.")
+ .def(py::init<>(&Mutex::create), py::call_guard<py::gil_scoped_release>(),
+ "Mutex constructor (pass True as a parameter to get a recursive Mutex).", py::arg("recursive") = false)
.def("lock", &Mutex::lock, py::call_guard<py::gil_scoped_release>(), "Block until the mutex is acquired.")
.def("try_lock", &Mutex::try_lock, py::call_guard<py::gil_scoped_release>(),
"Try to acquire the mutex. Return true if the mutex was acquired, false otherwise.")
},
"Add a callback called when each task ends.")
.def_property_readonly("name", &Task::get_name, "The name of this task (read-only).")
- .def_property_readonly("count", &Task::get_count, "The execution count of this task (read-only).")
.def_property_readonly("successors", &Task::get_successors, "The successors of this task (read-only).")
.def_property("amount", &Task::get_amount, &Task::set_amount, "The amount of work to do for this task.")
+ .def(
+ "get_count", [](const TaskPtr t) { return t->get_count("instance_0"); },
+ "The execution count of this task instance_0.")
+ .def(
+ "get_count", [](const TaskPtr t, const std::string& instance) { return t->get_count(instance); },
+ "The execution count of this task instance.")
.def("enqueue_firings", py::overload_cast<int>(&Task::enqueue_firings), py::call_guard<py::gil_scoped_release>(),
py::arg("n"), "Enqueue firings for this task.")
.def("add_successor", py::overload_cast<TaskPtr>(&Task::add_successor), py::call_guard<py::gil_scoped_release>(),