NetZone where each component is connected through a private link.
Cluster zones have a collection of private links that interconnect their components. This is particularly well adapted to model a collection of elements interconnected through a hub or a through a switch.
In a cluster, each component are given from 1 to 3 private links at creation:
- Private link (mandatory): link connecting the component to the cluster core.
- Limiter (optional): Additional link on the way from the component to the cluster core
- Loopback (optional): non-shared link connecting the component to itself.
Then, the cluster core may be constituted of a specific backbone link or not; A backbone can easily represent a network connected in a Hub. If you want to model a switch, either don't use a backbone at all, or use a fatpipe link (non-shared link) to represent the switch backplane.
* (outer world)
* |
* ======+====== <--backbone
* | | | |
* l0| l1| l2| l4| <-- private links + limiters
* | | | |
* X X X X <-- cluster's hosts
*
* (outer world)
* | <-- NO backbone
* /|\
* / | \ <-- private links + limiters __________
* / | \
* l0 / l1| \l2
* / | \
* host0 host1 host2
*
So, a communication from an host A to an host B goes through the following links (if they exist): limiter(A)_UP, private(A)_UP, backbone, private(B)_DOWN, limiter(B)_DOWN.
link_UP and link_DOWN usually share the exact same characteristics, but their performance are not shared, to model the fact that TCP links are full-duplex.
A cluster is connected to the outer world through a router that is connected directly to the cluster's backbone (no private link).
A communication from an host A to the outer world goes through the following links: limiter(A)_UP, private(A)_UP, backbone
(because the private router is directly connected to the cluster core).
|
| ClusterZone (NetZone *father, std::string name) |
|
void | getLocalRoute (NetPoint *src, NetPoint *dst, sg_platf_route_cbarg_t into, double *latency) override |
| Probe the routing path between two points that are local to the called NetZone. More...
|
|
void | getGraph (xbt_graph_t graph, std::map< std::string, xbt_node_t > *nodes, std::map< std::string, xbt_edge_t > *edges) override |
|
virtual void | create_links_for_node (ClusterCreationArgs *cluster, int id, int rank, unsigned int position) |
|
virtual void | parse_specific_arguments (ClusterCreationArgs *cluster) |
|
unsigned int | nodePosition (int id) |
|
unsigned int | nodePositionWithLoopback (int id) |
|
unsigned int | nodePositionWithLimiter (int id) |
|
simgrid::s4u::Host * | createHost (const char *name, std::vector< double > *speedPerPstate, int coreAmount, std::map< std::string, std::string > *props) |
| Make an host within that NetZone. More...
|
|
void | addBypassRoute (NetPoint *src, NetPoint *dst, NetPoint *gw_src, NetPoint *gw_dst, std::vector< simgrid::surf::LinkImpl *> &link_list, bool symmetrical) override |
| Creates a new route in this NetZone. More...
|
|
virtual void | seal () |
| Seal your netzone once you're done adding content, and before routing stuff through it. More...
|
|
const std::string & | getName () const |
| Retrieves the name of that netzone as a C++ string. More...
|
|
const char * | getCname () const |
| Retrieves the name of that netzone as a C string. More...
|
|
NetZone * | getFather () |
|
std::vector< NetZone * > * | getChildren () |
|
void | getHosts (std::vector< s4u::Host *> *whereto) |
|
std::unordered_map< std::string, std::string > * | getProperties () |
| Get the properties assigned to a host. More...
|
|
const char * | getProperty (const char *key) |
| Retrieve the property value (or nullptr if not set) More...
|
|
void | setProperty (const char *key, const char *value) |
|
virtual int | addComponent (kernel::routing::NetPoint *elm) |
|
virtual void | addRoute (kernel::routing::NetPoint *src, kernel::routing::NetPoint *dst, kernel::routing::NetPoint *gw_src, kernel::routing::NetPoint *gw_dst, std::vector< simgrid::surf::LinkImpl *> &link_list, bool symmetrical) |
|