for (int i = 0; i < tasks_count; i++) {
std::string worker_rank = std::to_string(i % workers_count);
std::string mailbox_name = std::string("worker-") + worker_rank;
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
mailbox->put(...);
Please also refer to the :ref:`full doc on s4u::Mailbox <s4u_mailbox>`.
-.. doxygentypedef:: MailboxPtr
-
.. doxygenclass:: simgrid::s4u::Mailbox
:members:
:protected-members:
/* - Select a worker in a round-robin way */
std::string worker_rank = std::to_string(i % workers_count);
std::string mailbox_name = std::string("worker-") + worker_rank;
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
/* - Send the computation cost to that worker */
XBT_INFO("Sending task %d of %ld to mailbox '%s'", i, tasks_count, mailbox->get_cname());
for (int i = 0; i < workers_count; i++) {
/* The workers stop when receiving a negative compute_cost */
std::string mailbox_name = std::string("worker-") + std::to_string(i);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
mailbox->put(new double(-1.0), 0);
}
long id = std::stol(args[1]);
const std::string mailbox_name = std::string("worker-") + std::to_string(id);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
double compute_cost;
do {
static void worker()
{
const std::string mailbox_name = std::string("worker-") + std::to_string(simgrid::s4u::this_actor::get_pid());
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
double compute_cost;
do {
/* - Select a worker in a round-robin way */
aid_t worker_pid = actors.at(i % actors.size())->get_pid();
std::string mailbox_name = std::string("worker-") + std::to_string(worker_pid);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
/* - Send the computation cost to that worker */
XBT_INFO("Sending task %d of %ld to mailbox '%s'", i, tasks_count, mailbox->get_cname());
for (unsigned long i = 0; i < actors.size(); i++) {
/* The workers stop when receiving a negative compute_cost */
std::string mailbox_name = std::string("worker-") + std::to_string(actors.at(i)->get_pid());
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
mailbox->put(new double(-1.0), 0);
}
static void worker()
{
const std::string mailbox_name = std::string("worker-") + std::to_string(simgrid::s4u::this_actor::get_pid());
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
while (true) { // Master forcefully kills the workers by the end of the simulation
double* msg = static_cast<double*>(mailbox->get());
/* - Select a worker in a round-robin way */
aid_t worker_pid = actors.at(task_id % actors.size())->get_pid();
std::string mailbox_name = std::string("worker-") + std::to_string(worker_pid);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
/* - Send the computation cost to that worker */
if (task_id % 100 == 0)
static void worker(std::string category)
{
const std::string mailbox_name = std::string("worker-") + std::to_string(simgrid::s4u::this_actor::get_pid());
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
while (true) { // Master forcefully kills the workers by the end of the simulation
double* msg = static_cast<double*>(mailbox->get());
/* - Select a worker in a round-robin way */
aid_t worker_pid = actors.at(task_id % actors.size())->get_pid();
std::string mailbox_name = std::string("worker-") + std::to_string(worker_pid);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
/* - Send the computation cost to that worker */
XBT_DEBUG("Sending task %d to mailbox '%s'", task_id, mailbox->get_cname());
*/
static void receiver(const std::string& mailbox_name)
{
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
XBT_INFO("Hello s4u, I'm ready to get any message you'd want on %s", mailbox->get_cname());
static int forwarder(int argc, char** argv)
{
xbt_assert(argc >= 3, "Actor forwarder requires 2 parameters, but got only %d", argc - 1);
- simgrid::s4u::MailboxPtr in = simgrid::s4u::Mailbox::by_name(argv[1]);
- simgrid::s4u::MailboxPtr out = simgrid::s4u::Mailbox::by_name(argv[2]);
+ simgrid::s4u::Mailbox* in = simgrid::s4u::Mailbox::by_name(argv[1]);
+ simgrid::s4u::Mailbox* out = simgrid::s4u::Mailbox::by_name(argv[2]);
std::string* msg = static_cast<std::string*>(in->get());
XBT_INFO("Forward '%s'.", msg->c_str());
out->put(msg, msg->size());
void operator()() /* This is the main code of the actor */
{
XBT_INFO("Hello s4u, I have something to send");
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mbox);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(mbox);
mailbox->put(new std::string(msg), msg.size());
XBT_INFO("I'm done. See you.");
public:
e_message_type type;
int peer_id;
- simgrid::s4u::MailboxPtr return_mailbox;
+ simgrid::s4u::Mailbox* return_mailbox;
unsigned int bitfield = 0U;
int piece = 0;
int block_index = 0;
int block_length = 0;
- Message(e_message_type type, int peer_id, simgrid::s4u::MailboxPtr return_mailbox)
+ Message(e_message_type type, int peer_id, simgrid::s4u::Mailbox* return_mailbox)
: type(type), peer_id(peer_id), return_mailbox(return_mailbox){};
- Message(e_message_type type, int peer_id, unsigned int bitfield, simgrid::s4u::MailboxPtr return_mailbox)
+ Message(e_message_type type, int peer_id, unsigned int bitfield, simgrid::s4u::Mailbox* return_mailbox)
: type(type), peer_id(peer_id), return_mailbox(return_mailbox), bitfield(bitfield){};
- Message(e_message_type type, int peer_id, simgrid::s4u::MailboxPtr return_mailbox, int piece, int block_index,
+ Message(e_message_type type, int peer_id, simgrid::s4u::Mailbox* return_mailbox, int piece, int block_index,
int block_length)
: type(type)
, peer_id(peer_id)
, piece(piece)
, block_index(block_index)
, block_length(block_length){};
- Message(e_message_type type, int peer_id, simgrid::s4u::MailboxPtr return_mailbox, int piece)
+ Message(e_message_type type, int peer_id, simgrid::s4u::Mailbox* return_mailbox, int piece)
: type(type), peer_id(peer_id), return_mailbox(return_mailbox), piece(piece){};
~Message() = default;
};
bool Peer::getPeersFromTracker()
{
- simgrid::s4u::MailboxPtr tracker_mailbox = simgrid::s4u::Mailbox::by_name(TRACKER_MAILBOX);
+ simgrid::s4u::Mailbox* tracker_mailbox = simgrid::s4u::Mailbox::by_name(TRACKER_MAILBOX);
// Build the task to send to the tracker
TrackerQuery* peer_request = new TrackerQuery(id, mailbox_);
try {
}
}
-void Peer::sendMessage(simgrid::s4u::MailboxPtr mailbox, e_message_type type, uint64_t size)
+void Peer::sendMessage(simgrid::s4u::Mailbox* mailbox, e_message_type type, uint64_t size)
{
const char* type_names[6] = {"HANDSHAKE", "CHOKE", "UNCHOKE", "INTERESTED", "NOTINTERESTED", "CANCEL"};
XBT_DEBUG("Sending %s to %s", type_names[type], mailbox->get_cname());
mailbox->put_init(new Message(type, id, bitfield_, mailbox_), size)->detach();
}
-void Peer::sendBitfield(simgrid::s4u::MailboxPtr mailbox)
+void Peer::sendBitfield(simgrid::s4u::Mailbox* mailbox)
{
XBT_DEBUG("Sending a BITFIELD to %s", mailbox->get_cname());
mailbox
->detach();
}
-void Peer::sendPiece(simgrid::s4u::MailboxPtr mailbox, unsigned int piece, int block_index, int block_length)
+void Peer::sendPiece(simgrid::s4u::Mailbox* mailbox, unsigned int piece, int block_index, int block_length)
{
xbt_assert(not hasNotPiece(piece), "Tried to send a unavailable piece.");
XBT_DEBUG("Sending the PIECE %u (%d,%d) to %s", piece, block_index, block_length, mailbox->get_cname());
class Connection {
public:
int id; // Peer id
- simgrid::s4u::MailboxPtr mailbox_;
+ simgrid::s4u::Mailbox* mailbox_;
unsigned int bitfield = 0U; // Fields
// int messages_count;
double peer_speed = 0;
int id;
double deadline;
RngStream stream;
- simgrid::s4u::MailboxPtr mailbox_;
+ simgrid::s4u::Mailbox* mailbox_;
std::unordered_map<int, Connection*> connected_peers;
std::set<Connection*> active_peers; // active peers list
void requestNewPieceTo(Connection* remote_peer);
bool getPeersFromTracker();
- void sendMessage(simgrid::s4u::MailboxPtr mailbox, e_message_type type, uint64_t size);
- void sendBitfield(simgrid::s4u::MailboxPtr mailbox);
- void sendPiece(simgrid::s4u::MailboxPtr mailbox, unsigned int piece, int block_index, int block_length);
+ void sendMessage(simgrid::s4u::Mailbox* mailbox, e_message_type type, uint64_t size);
+ void sendBitfield(simgrid::s4u::Mailbox* mailbox);
+ void sendPiece(simgrid::s4u::Mailbox* mailbox, unsigned int piece, int block_index, int block_length);
void sendHandshakeToAllPeers();
void sendHaveToAllPeers(unsigned int piece);
void sendRequestTo(Connection* remote_peer, unsigned int piece);
class TrackerQuery {
int peer_id; // peer id
- simgrid::s4u::MailboxPtr return_mailbox;
+ simgrid::s4u::Mailbox* return_mailbox;
+
public:
- explicit TrackerQuery(int peer_id, simgrid::s4u::MailboxPtr return_mailbox)
+ explicit TrackerQuery(int peer_id, simgrid::s4u::Mailbox* return_mailbox)
: peer_id(peer_id), return_mailbox(return_mailbox){};
~TrackerQuery() = default;
int getPeerId() { return peer_id; }
- simgrid::s4u::MailboxPtr getReturnMailbox() { return return_mailbox; }
+ simgrid::s4u::Mailbox* getReturnMailbox() { return return_mailbox; }
};
class TrackerAnswer {
class Tracker {
double deadline;
RngStream stream;
- simgrid::s4u::MailboxPtr mailbox;
+ simgrid::s4u::Mailbox* mailbox;
std::set<int> known_peers;
public:
class ChainMessage {
public:
- simgrid::s4u::MailboxPtr prev_ = nullptr;
- simgrid::s4u::MailboxPtr next_ = nullptr;
+ simgrid::s4u::Mailbox* prev_ = nullptr;
+ simgrid::s4u::Mailbox* next_ = nullptr;
unsigned int num_pieces = 0;
- explicit ChainMessage(simgrid::s4u::MailboxPtr prev, simgrid::s4u::MailboxPtr next, const unsigned int num_pieces)
+ explicit ChainMessage(simgrid::s4u::Mailbox* prev, simgrid::s4u::Mailbox* next, const unsigned int num_pieces)
: prev_(prev), next_(next), num_pieces(num_pieces)
{
}
class Peer {
public:
- simgrid::s4u::MailboxPtr prev = nullptr;
- simgrid::s4u::MailboxPtr next = nullptr;
- simgrid::s4u::MailboxPtr me = nullptr;
+ simgrid::s4u::Mailbox* prev = nullptr;
+ simgrid::s4u::Mailbox* next = nullptr;
+ simgrid::s4u::Mailbox* me = nullptr;
std::vector<simgrid::s4u::CommPtr> pending_recvs;
std::vector<simgrid::s4u::CommPtr> pending_sends;
class Broadcaster {
public:
- simgrid::s4u::MailboxPtr first = nullptr;
- std::vector<simgrid::s4u::MailboxPtr> mailboxes;
+ simgrid::s4u::Mailbox* first = nullptr;
+ std::vector<simgrid::s4u::Mailbox*> mailboxes;
unsigned int piece_count;
void buildChain()
{
auto cur = mailboxes.begin();
- simgrid::s4u::MailboxPtr prev = nullptr;
- simgrid::s4u::MailboxPtr last = nullptr;
+ simgrid::s4u::Mailbox* prev = nullptr;
+ simgrid::s4u::Mailbox* last = nullptr;
/* Build the chain if there's at least one peer */
if (cur != mailboxes.end()) {
/* init: prev=NULL, host=current cur, next=next cur */
- simgrid::s4u::MailboxPtr next = *cur;
+ simgrid::s4u::Mailbox* next = *cur;
first = next;
/* This iterator iterates one step ahead: cur is current iterated element, but is actually next in the chain */
/* following steps: prev=last, host=next, next=cur */
++cur;
prev = last;
- simgrid::s4u::MailboxPtr current_mailbox = next;
+ simgrid::s4u::Mailbox* current_mailbox = next;
if (cur != mailboxes.end())
next = *cur;
else
long tasks_count = 0;
double compute_cost = 0;
double communicate_cost = 0;
- std::vector<simgrid::s4u::MailboxPtr> workers;
+ std::vector<simgrid::s4u::Mailbox*> workers;
public:
explicit Master(std::vector<std::string> args)
{
for (int i = 0; i < tasks_count; i++) { /* For each task to be executed: */
/* - Select a worker in a round-robin way */
- simgrid::s4u::MailboxPtr mailbox = workers[i % workers.size()];
+ simgrid::s4u::Mailbox* mailbox = workers[i % workers.size()];
/* - Send the computation amount to the worker */
if (tasks_count < 10000 || (tasks_count < 100000 && i % 10000 == 0) || i % 100000 == 0)
XBT_INFO("All tasks have been dispatched. Request all workers to stop.");
for (unsigned int i = 0; i < workers.size(); i++) {
/* The workers stop when receiving a negative compute_cost */
- simgrid::s4u::MailboxPtr mailbox = workers[i % workers.size()];
+ simgrid::s4u::Mailbox* mailbox = workers[i % workers.size()];
mailbox->put(new double(-1.0), 0);
}
}
};
class Worker {
- simgrid::s4u::MailboxPtr mailbox = nullptr;
+ simgrid::s4u::Mailbox* mailbox = nullptr;
public:
explicit Worker(std::vector<std::string> args)
long tasks_count = std::stol(args[1]);
double compute_cost = std::stod(args[2]);
double communication_cost = std::stod(args[3]);
- std::vector<simgrid::s4u::MailboxPtr> workers;
+ std::vector<simgrid::s4u::Mailbox*> workers;
for (unsigned int i = 4; i < args.size(); i++)
workers.push_back(simgrid::s4u::Mailbox::by_name(args[i]));
for (int i = 0; i < tasks_count; i++) { /* For each task to be executed: */
/* - Select a worker in a round-robin way */
- simgrid::s4u::MailboxPtr mailbox = workers[i % workers.size()];
+ simgrid::s4u::Mailbox* mailbox = workers[i % workers.size()];
/* - Send the computation cost to that worker */
XBT_INFO("Sending task %d of %ld to mailbox '%s'", i, tasks_count, mailbox->get_cname());
XBT_INFO("All tasks have been dispatched. Request all workers to stop.");
for (unsigned int i = 0; i < workers.size(); i++) {
/* The workers stop when receiving a negative compute_cost */
- simgrid::s4u::MailboxPtr mailbox = workers[i % workers.size()];
+ simgrid::s4u::Mailbox* mailbox = workers[i % workers.size()];
mailbox->put(new double(-1.0), 0);
}
xbt_assert(args.size() == 1, "The worker expects no argument");
simgrid::s4u::Host* my_host = simgrid::s4u::this_actor::get_host();
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(my_host->get_name());
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(my_host->get_name());
double compute_cost;
do {
XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_app_pingpong, "Messages specific for this s4u example");
-static void pinger(simgrid::s4u::MailboxPtr mailbox_in, simgrid::s4u::MailboxPtr mailbox_out)
+static void pinger(simgrid::s4u::Mailbox* mailbox_in, simgrid::s4u::Mailbox* mailbox_out)
{
XBT_INFO("Ping from mailbox %s to mailbox %s", mailbox_in->get_name().c_str(), mailbox_out->get_name().c_str());
delete sender_time;
}
-static void ponger(simgrid::s4u::MailboxPtr mailbox_in, simgrid::s4u::MailboxPtr mailbox_out)
+static void ponger(simgrid::s4u::Mailbox* mailbox_in, simgrid::s4u::Mailbox* mailbox_out)
{
XBT_INFO("Pong from mailbox %s to mailbox %s", mailbox_in->get_name().c_str(), mailbox_out->get_name().c_str());
simgrid::s4u::Engine e(&argc, argv);
e.load_platform(argv[1]);
- simgrid::s4u::MailboxPtr mb1 = simgrid::s4u::Mailbox::by_name("Mailbox 1");
- simgrid::s4u::MailboxPtr mb2 = simgrid::s4u::Mailbox::by_name("Mailbox 2");
+ simgrid::s4u::Mailbox* mb1 = simgrid::s4u::Mailbox::by_name("Mailbox 1");
+ simgrid::s4u::Mailbox* mb2 = simgrid::s4u::Mailbox::by_name("Mailbox 2");
simgrid::s4u::Actor::create("pinger", simgrid::s4u::Host::by_name("Tremblay"), pinger, mb1, mb2);
simgrid::s4u::Actor::create("ponger", simgrid::s4u::Host::by_name("Jupiter"), ponger, mb2, mb1);
class RelayRunner {
size_t task_comm_size = 1000000; /* The token is 1MB long*/
- simgrid::s4u::MailboxPtr my_mailbox;
- simgrid::s4u::MailboxPtr neighbor_mailbox;
+ simgrid::s4u::Mailbox* my_mailbox;
+ simgrid::s4u::Mailbox* neighbor_mailbox;
unsigned int rank = 0;
public:
long peers_count = std::stod(argv[4]); /* - number of peers */
/* Set myself as the persistent receiver of my mailbox so that messages start flowing to me as soon as they are put into it */
- simgrid::s4u::MailboxPtr my_mbox = simgrid::s4u::Mailbox::by_name(std::string("peer-") + std::to_string(my_id));
+ simgrid::s4u::Mailbox* my_mbox = simgrid::s4u::Mailbox::by_name(std::string("peer-") + std::to_string(my_id));
my_mbox->set_receiver(simgrid::s4u::Actor::self());
std::vector<simgrid::s4u::CommPtr> pending_comms;
for (int peer_id = 0; peer_id < peers_count; peer_id++) {
if (peer_id != my_id) {
std::string mboxName = std::string("peer-") + std::to_string(peer_id);
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(mboxName);
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(mboxName);
std::string msgName = std::string("Message ") + std::to_string(i) + std::string(" from peer ") + std::to_string(my_id);
std::string* payload = new std::string(msgName); // copy the data we send:
// 'msgName' is not a stable storage location
for (int peer_id = 0; peer_id < peers_count; peer_id++) {
if (peer_id != my_id) {
std::string mboxName = std::string("peer-") + std::to_string(peer_id);
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(mboxName);
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(mboxName);
std::string* payload = new std::string("finalize"); // Make a copy of the data we will send
pending_comms.push_back(mbox->put_async(payload, msg_size));
XBT_INFO("Send 'finalize' to 'peer-%d'", peer_id);
std::vector<simgrid::s4u::CommPtr> pending_comms;
/* Make a vector of the mailboxes to use */
- std::vector<simgrid::s4u::MailboxPtr> mboxes;
+ std::vector<simgrid::s4u::Mailbox*> mboxes;
for (int i = 0; i < receivers_count; i++)
mboxes.push_back(simgrid::s4u::Mailbox::by_name(std::string("receiver-") + std::to_string(i)));
static int receiver(int argc, char** argv)
{
xbt_assert(argc == 2, "Expecting one parameter from the XML deployment file but got %d", argc);
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(std::string("receiver-") + argv[1]);
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(std::string("receiver-") + argv[1]);
XBT_INFO("Wait for my first message");
for (bool cont = true; cont;) {
std::vector<simgrid::s4u::CommPtr> pending_comms;
/* Make a vector of the mailboxes to use */
- std::vector<simgrid::s4u::MailboxPtr> mboxes;
+ std::vector<simgrid::s4u::Mailbox*> mboxes;
for (int i = 0; i < receivers_count; i++)
mboxes.push_back(simgrid::s4u::Mailbox::by_name(std::string("receiver-") + std::to_string(i)));
// sphinx-doc: init-end
/* Receiver actor expects 1 argument: its ID */
class Receiver {
- simgrid::s4u::MailboxPtr mbox;
+ simgrid::s4u::Mailbox* mbox;
public:
explicit Receiver(std::vector<std::string> args)
std::vector<simgrid::s4u::CommPtr> pending_comms;
/* Make a vector of the mailboxes to use */
- std::vector<simgrid::s4u::MailboxPtr> mboxes;
+ std::vector<simgrid::s4u::Mailbox*> mboxes;
for (int i = 0; i < receivers_count; i++)
mboxes.push_back(simgrid::s4u::Mailbox::by_name(std::string("receiver-") + std::to_string(i)));
/* Receiver actor expects 1 argument: its ID */
class Receiver {
- simgrid::s4u::MailboxPtr mbox;
+ simgrid::s4u::Mailbox* mbox;
public:
explicit Receiver(std::vector<std::string> args)
for (int i = 0; i < messages_count; i++) {
std::string mboxName = std::string("receiver-") + std::to_string(i % receivers_count);
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(mboxName);
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(mboxName);
std::string msgName = std::string("Message ") + std::to_string(i);
std::string* payload = new std::string(msgName); // copy the data we send:
// 'msgName' is not a stable storage location
/* Start sending messages to let the workers know that they should stop */
for (int i = 0; i < receivers_count; i++) {
std::string mboxName = std::string("receiver-") + std::to_string(i % receivers_count);
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(mboxName);
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(mboxName);
std::string* payload = new std::string("finalize"); // Make a copy of the data we will send
simgrid::s4u::CommPtr comm = mbox->put_async(payload, 0);
static int receiver(int argc, char** argv)
{
xbt_assert(argc == 2, "Expecting one parameter from the XML deployment file but got %d", argc);
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(std::string("receiver-") + argv[1]);
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(std::string("receiver-") + argv[1]);
XBT_INFO("Wait for my first message");
for (bool cont = true; cont;) {
static void communication_tx_fun(std::vector<std::string> args)
{
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(args.at(0));
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(args.at(0));
s_payload* payload = new s_payload;
payload->tx_actor_name = simgrid::s4u::Actor::self()->get_cname();
payload->tx_host = simgrid::s4u::this_actor::get_host();
{
const char* actor_name = simgrid::s4u::Actor::self()->get_cname();
const char* host_name = simgrid::s4u::this_actor::get_host()->get_cname();
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(args.at(0));
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(args.at(0));
struct s_payload* payload = static_cast<struct s_payload*>(mbox->get());
double clock_end = simgrid::s4u::Engine::get_clock();
if (pred_id_ == -1)
return;
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(pred_id_));
- simgrid::s4u::MailboxPtr return_mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_) + "_is_alive");
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(pred_id_));
+ simgrid::s4u::Mailbox* return_mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_) + "_is_alive");
ChordMessage* message = new ChordMessage(PREDECESSOR_ALIVE);
message->request_id = pred_id_;
{
int predecessor_id = -1;
void* data = nullptr;
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(ask_to));
- simgrid::s4u::MailboxPtr return_mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_) + "_pred");
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(ask_to));
+ simgrid::s4u::Mailbox* return_mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_) + "_pred");
ChordMessage* message = new ChordMessage(GET_PREDECESSOR);
message->request_id = id_;
{
int successor = -1;
void* data = nullptr;
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(ask_to));
- simgrid::s4u::MailboxPtr return_mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_) + "_succ");
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(ask_to));
+ simgrid::s4u::Mailbox* return_mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_) + "_succ");
ChordMessage* message = new ChordMessage(FIND_SUCCESSOR);
message->request_id = id_;
// send a "Notify" request to notify_id
XBT_DEBUG("Sending a 'Notify' request to %d", notify_id);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(notify_id));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(notify_id));
mailbox->put_init(message, 10)->detach(ChordMessage::destroy);
}
int closest = closestPrecedingFinger(message->request_id);
XBT_DEBUG("Forwarding the 'Find Successor' request for id %d to my closest preceding finger %d",
message->request_id, closest);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(closest));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(closest));
mailbox->put_init(message, 10)->detach(ChordMessage::destroy);
}
break;
int request_id = -1; // id (used by some types of messages)
int request_finger = 1; // finger parameter (used by some types of messages)
int answer_id = -1; // answer (used by some types of messages)
- simgrid::s4u::MailboxPtr answer_to; // mailbox to send an answer to (if any)
+ simgrid::s4u::Mailbox* answer_to; // mailbox to send an answer to (if any)
explicit ChordMessage(e_message_type_t type)
: type(type), issuer_host_name(simgrid::s4u::this_actor::get_host()->get_name())
bool joined = false;
int id_; // my id
int pred_id_ = -1; // predecessor id
- simgrid::s4u::MailboxPtr mailbox_; // my mailbox
+ simgrid::s4u::Mailbox* mailbox_; // my mailbox
int* fingers_; // finger table,(fingers[0] is my successor)
int next_finger_to_fix; // index of the next finger to fix in fix_fingers()
RngStream stream;
unsigned int sender_id_ = 0; // Id of the guy who sent the task
unsigned int destination_id_ = 0; // Id we are trying to find, if needed.
Answer* answer_ = nullptr; // Answer to the request made, if needed.
- simgrid::s4u::MailboxPtr answer_to_ = nullptr; // mailbox to send the answer to (if not an answer).
+ simgrid::s4u::Mailbox* answer_to_ = nullptr; // mailbox to send the answer to (if not an answer).
std::string issuer_host_name_; // used for logging
- explicit Message(unsigned int sender_id, unsigned int destination_id, Answer* answer,
- simgrid::s4u::MailboxPtr mailbox, const char* hostname)
+ explicit Message(unsigned int sender_id, unsigned int destination_id, Answer* answer, simgrid::s4u::Mailbox* mailbox,
+ const char* hostname)
: sender_id_(sender_id)
, destination_id_(destination_id)
, answer_(answer)
, issuer_host_name_(hostname)
{
}
- explicit Message(unsigned int sender_id, unsigned int destination_id, simgrid::s4u::MailboxPtr mailbox,
+ explicit Message(unsigned int sender_id, unsigned int destination_id, simgrid::s4u::Mailbox* mailbox,
const char* hostname)
: Message(sender_id, destination_id, nullptr, mailbox, hostname)
{
/* First step: Send a "FIND_NODE" request to the node we know */
sendFindNode(known_id, id_);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_));
do {
if (receive_comm == nullptr)
receive_comm = mailbox->get_async(&received_msg);
void Node::sendFindNode(unsigned int id, unsigned int destination)
{
/* Gets the mailbox to send to */
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id));
/* Build the task */
Message* msg = new Message(id_, destination, simgrid::s4u::Mailbox::by_name(std::to_string(id_)),
simgrid::s4u::Host::current()->get_cname());
steps++;
double time_beginreceive = simgrid::s4u::Engine::get_clock();
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(id_));
do {
if (receive_comm == nullptr)
receive_comm = mailbox->get_async(&received_msg);
XBT_VERB("Main loop start");
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(node->getId()));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::to_string(node->getId()));
while (simgrid::s4u::Engine::get_clock() < deadline) {
if (node->receive_comm == nullptr)
double comm_size = std::stod(args.at(1));
XBT_INFO("Send %.0f bytes, in %d flows", comm_size, flow_amount);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::string("message"));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::string("message"));
/* Sleep a while before starting the example */
simgrid::s4u::this_actor::sleep_for(10);
XBT_INFO("Receiving %d flows ...", flow_amount);
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::string("message"));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::string("message"));
if (flow_amount == 1) {
void* res = mailbox->get();
{
xbt_assert(argc == 5, "Expecting one parameter");
- simgrid::s4u::MailboxPtr mailbox;
+ simgrid::s4u::Mailbox* mailbox;
long number_of_tasks = xbt_str_parse_int(argv[1], "Invalid amount of tasks: %s");
double comp_size = xbt_str_parse_double(argv[2], "Invalid computational size: %s");
double comm_size = xbt_str_parse_double(argv[3], "Invalid communication size: %s");
{
xbt_assert(argc == 2, "Expecting one parameter");
long id = xbt_str_parse_int(argv[1], "Invalid argument %s");
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(std::string("worker-") + std::to_string(id));
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(std::string("worker-") + std::to_string(id));
double* payload = nullptr;
double comp_size = -1;
while (1) {
double size = std::stod(action[3]);
std::string* payload = new std::string(action[3]);
double clock = simgrid::s4u::Engine::get_clock();
- simgrid::s4u::MailboxPtr to =
- simgrid::s4u::Mailbox::by_name(simgrid::s4u::this_actor::get_name() + "_" + action[2]);
+ simgrid::s4u::Mailbox* to = simgrid::s4u::Mailbox::by_name(simgrid::s4u::this_actor::get_name() + "_" + action[2]);
ACT_DEBUG("Entering Send: %s (size: %g) -- Actor %s on mailbox %s", NAME.c_str(), size,
simgrid::s4u::this_actor::get_cname(), to->get_cname());
to->put(payload, size);
static void recv(simgrid::xbt::ReplayAction& action)
{
double clock = simgrid::s4u::Engine::get_clock();
- simgrid::s4u::MailboxPtr from =
+ simgrid::s4u::Mailbox* from =
simgrid::s4u::Mailbox::by_name(std::string(action[2]) + "_" + simgrid::s4u::this_actor::get_name());
ACT_DEBUG("Receiving: %s -- Actor %s on mailbox %s", NAME.c_str(), simgrid::s4u::this_actor::get_cname(),
class Link;
class Mailbox;
-/** Smart pointer to a simgrid::s4u::Mailbox */
-typedef boost::intrusive_ptr<Mailbox> MailboxPtr;
-XBT_PUBLIC void intrusive_ptr_release(Mailbox* m);
-XBT_PUBLIC void intrusive_ptr_add_ref(Mailbox* m);
class Mutex;
XBT_PUBLIC void intrusive_ptr_release(Mutex* m);
* Represents all asynchronous communications, that you can test or wait onto.
*/
class XBT_PUBLIC Comm : public Activity {
- MailboxPtr mailbox_ = nullptr;
+ Mailbox* mailbox_ = nullptr;
kernel::actor::ActorImpl* sender_ = nullptr;
kernel::actor::ActorImpl* receiver_ = nullptr;
double rate_ = -1;
CommPtr set_dst_data(void** buff, size_t size);
/** Retrieve the mailbox on which this comm acts */
- MailboxPtr get_mailbox();
+ Mailbox* get_mailbox();
/** Retrieve the size of the received data. Not to be mixed with @ref Activity::set_remaining() */
size_t get_dst_data_size();
{
return get_dst_data_size();
}
- XBT_ATTRIB_DEPRECATED_v323("Please use Comm::get_mailbox()") MailboxPtr getMailbox() { return get_mailbox(); }
+ XBT_ATTRIB_DEPRECATED_v323("Please use Comm::get_mailbox()") Mailbox* getMailbox() { return get_mailbox(); }
#endif
};
} // namespace s4u
explicit Mailbox(kernel::activity::MailboxImpl * mbox) : pimpl_(mbox) {}
- /** private function to manage the mailboxes' lifetime (see @ref s4u_raii) */
- friend void intrusive_ptr_add_ref(Mailbox*) {}
- /** private function to manage the mailboxes' lifetime (see @ref s4u_raii) */
- friend void intrusive_ptr_release(Mailbox*) {}
-
public:
/** private function, do not use. FIXME: make me protected */
kernel::activity::MailboxImpl* get_impl() { return pimpl_; }
const char* get_cname() const;
/** Retrieve the mailbox associated to the given name */
- static MailboxPtr by_name(const std::string& name);
+ static Mailbox* by_name(const std::string& name);
/** Returns whether the mailbox contains queued communications */
bool empty();
return get_impl();
}
/** @deprecated Mailbox::by_name() */
- XBT_ATTRIB_DEPRECATED_v323("Please use Mailbox::by_name()") static MailboxPtr byName(const char* name)
+ XBT_ATTRIB_DEPRECATED_v323("Please use Mailbox::by_name()") static Mailbox* byName(const char* name)
{
return by_name(name);
}
/** @deprecated Mailbox::by_name() */
- XBT_ATTRIB_DEPRECATED_v323("Please use Mailbox::by_name()") static MailboxPtr byName(const std::string& name)
+ XBT_ATTRIB_DEPRECATED_v323("Please use Mailbox::by_name()") static Mailbox* byName(const std::string& name)
{
return by_name(name);
}
static constexpr size_t MAX_MAILBOX_SIZE = 10000000;
friend s4u::Mailbox;
- friend s4u::MailboxPtr s4u::Mailbox::by_name(const std::string& name);
+ friend s4u::Mailbox* s4u::Mailbox::by_name(const std::string& name);
friend mc::CommunicationDeterminismChecker;
explicit MailboxImpl(const std::string& name)
*/
msg_comm_t MSG_task_irecv_bounded(msg_task_t* task, const char* name, double rate)
{
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(name);
-
/* FIXME: these functions are not traceable */
/* Sanity check */
xbt_assert(task, "Null pointer for the task storage");
/* wait until the migration have finished or on error has occurred */
XBT_DEBUG("wait for reception of the final ACK (i.e. migration has been correctly performed");
- simgrid::s4u::MailboxPtr mbox_ctl = simgrid::s4u::Mailbox::by_name(
+ simgrid::s4u::Mailbox* mbox_ctl = simgrid::s4u::Mailbox::by_name(
std::string("__mbox_mig_ctl:") + vm->get_cname() + "(" + src_pm->get_cname() + "-" + dst_pm->get_cname() + ")");
delete static_cast<std::string*>(mbox_ctl->get());
tx->join();
class MigrationRx {
/* The miration_rx process uses mbox_ctl to let the caller of do_migration() know the completion of the migration. */
- s4u::MailboxPtr mbox_ctl;
+ s4u::Mailbox* mbox_ctl;
/* The migration_rx and migration_tx processes use mbox to transfer migration data. */
- s4u::MailboxPtr mbox;
+ s4u::Mailbox* mbox;
s4u::VirtualMachine* vm_;
s4u::Host* src_pm_ = nullptr;
s4u::Host* dst_pm_ = nullptr;
class MigrationTx {
/* The migration_rx and migration_tx processes use mbox to transfer migration data. */
- s4u::MailboxPtr mbox;
+ s4u::Mailbox* mbox;
s4u::VirtualMachine* vm_;
s4u::Host* src_pm_ = nullptr;
s4u::Host* dst_pm_ = nullptr;
return false;
}
-MailboxPtr Comm::get_mailbox()
+Mailbox* Comm::get_mailbox()
{
return mailbox_;
}
return pimpl_->get_cname();
}
-MailboxPtr Mailbox::by_name(const 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 &mbox->piface_;
}
bool Mailbox::empty()
class ActorExt {
private:
double simulated_ = 0 /* Used to time with simulated_start/elapsed */;
- s4u::MailboxPtr mailbox_;
- s4u::MailboxPtr mailbox_small_;
+ s4u::Mailbox* mailbox_;
+ s4u::Mailbox* mailbox_small_;
s4u::MutexPtr mailboxes_mutex_;
xbt_os_timer_t timer_;
MPI_Comm comm_self_ = MPI_COMM_NULL;
smpi_trace_call_location_t* call_location();
void set_privatized_region(smpi_privatization_region_t region);
smpi_privatization_region_t privatized_region();
- s4u::MailboxPtr mailbox() { return mailbox_; }
- s4u::MailboxPtr mailbox_small() { return mailbox_small_; }
+ s4u::Mailbox* mailbox() { return mailbox_; }
+ s4u::Mailbox* mailbox_small() { return mailbox_small_; }
s4u::MutexPtr mailboxes_mutex();
#if HAVE_PAPI
int papi_event_set();
void Request::start()
{
- s4u::MailboxPtr mailbox;
+ s4u::Mailbox* mailbox;
xbt_assert(action_ == nullptr, "Cannot (re-)start unfinished communication");
flags_ &= ~MPI_REQ_PREPARED;
->wait();
}
// behave like a receive, but don't do it
- s4u::MailboxPtr mailbox;
+ s4u::Mailbox* mailbox;
request->print_request("New iprobe");
// We have to test both mailboxes as we don't know if we will receive one one or another
for (unsigned int test = 1; test <= args[0].size(); test++) {
simgrid::s4u::this_actor::sleep_until(test * 5 - 5);
std::string* mboxName = new std::string("Test #" + std::to_string(test));
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(*mboxName);
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(*mboxName);
switch (args[0][test - 1]) {
case 'r':
for (unsigned int test = 1; test <= args[0].size(); test++) {
simgrid::s4u::this_actor::sleep_until(test * 5 - 5);
std::string mboxName = "Test #" + std::to_string(test);
- simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::by_name(mboxName);
+ simgrid::s4u::Mailbox* mbox = simgrid::s4u::Mailbox::by_name(mboxName);
void* received = nullptr;
switch (args[0][test - 1]) {
static void server()
{
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name("mailbox");
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name("mailbox");
simgrid::s4u::CommPtr sendComm = mailbox->put_async(new std::string("Some data"), 0);
delete res;
sendComm->wait();
- simgrid::s4u::MailboxPtr mailbox2 = simgrid::s4u::Mailbox::by_name("mailbox2");
+ simgrid::s4u::Mailbox* mailbox2 = simgrid::s4u::Mailbox::by_name("mailbox2");
mailbox2->set_receiver(simgrid::s4u::Actor::self());
mailbox2->put_init(new std::string("More data"), 0)->detach();
static void sendpid()
{
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name("mailbox");
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name("mailbox");
int pid = simgrid::s4u::this_actor::get_pid();
double comm_size = 100000;
simgrid::s4u::this_actor::on_exit([pid](bool /*failed*/) { XBT_INFO("Process \"%d\" killed.", pid); });
static void killall()
{
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name("mailbox");
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name("mailbox");
for (int i = 0; i < 3; i++) {
int* pid = static_cast<int*>(mailbox->get());
XBT_INFO("Killing process \"%d\".", *pid);
// Send file
XBT_INFO("%s sends %llu to %s", simgrid::s4u::this_actor::get_cname(), read_size, remote_host.c_str());
std::string* payload = new std::string(simgrid::xbt::string_printf("%s %llu", dest.c_str(), read_size));
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(remote_host);
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(remote_host);
mailbox->put(payload, static_cast<double>(read_size));
simgrid::s4u::this_actor::sleep_for(.4);
}
hsm_put("alice", "/home/doc/simgrid/examples/msg/parallel_task/test_ptask_deployment.xml", "c:\\Windows\\titi.xml");
hsm_put("alice", "/home/doc/simgrid/examples/msg/alias/masterslave_forwarder_with_alias.c", "c:\\Windows\\tata.c");
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name("alice");
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name("alice");
mailbox->put(new std::string("finalize"), 0);
get_set_storage_data("Disk1");
static void server()
{
storage_info(simgrid::s4u::this_actor::get_host());
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(simgrid::s4u::this_actor::get_host()->get_cname());
+ simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(simgrid::s4u::this_actor::get_host()->get_cname());
XBT_INFO("Server waiting for transfers ...");
while (1) {