X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7e2f1b12f4459f77318e5d664317473e35aeb473..2c0aa88e3d941e79fc79d39e3e58224d282b76d3:/examples/s4u/dht-chord/s4u-dht-chord-node.cpp

diff --git a/examples/s4u/dht-chord/s4u-dht-chord-node.cpp b/examples/s4u/dht-chord/s4u-dht-chord-node.cpp
index e1d3c23103..abb632b77c 100644
--- a/examples/s4u/dht-chord/s4u-dht-chord-node.cpp
+++ b/examples/s4u/dht-chord/s4u-dht-chord-node.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2010-2019. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2010-2020. 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. */
@@ -20,9 +20,9 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(s4u_chord);
  * @param id id to check
  * @param start lower bound
  * @param end upper bound
- * @return a non-zero value if id in in [start, end]
+ * @return true if id in in [start, end]
  */
-static int is_in_interval(int id, int start, int end)
+static bool is_in_interval(int id, int start, int end)
 {
   int i = id % nb_keys;
   int s = start % nb_keys;
@@ -52,7 +52,8 @@ Node::Node(std::vector<std::string> args)
 
   // initialize my node
   id_                = std::stoi(args[1]);
-  stream             = simgrid::s4u::this_actor::get_host()->extension<HostChord>()->getStream();
+  XBT_DEBUG("Initialize node with id: %d", id_);
+  random.set_seed(id_);
   mailbox_           = simgrid::s4u::Mailbox::by_name(std::to_string(id_));
   next_finger_to_fix = 0;
   fingers_.resize(nb_bits, id_);
@@ -103,28 +104,28 @@ void Node::leave()
 void Node::notifyAndQuit()
 {
   // send the PREDECESSOR_LEAVING to our successor
-  ChordMessage* pred_msg = new ChordMessage(PREDECESSOR_LEAVING);
+  auto* pred_msg         = new ChordMessage(PREDECESSOR_LEAVING);
   pred_msg->request_id   = pred_id_;
   pred_msg->answer_to    = mailbox_;
 
   XBT_DEBUG("Sending a 'PREDECESSOR_LEAVING' to my successor %d", fingers_[0]);
   try {
     simgrid::s4u::Mailbox::by_name(std::to_string(fingers_[0]))->put(pred_msg, 10, timeout);
-  } catch (const simgrid::TimeoutError&) {
+  } catch (const simgrid::TimeoutException&) {
     XBT_DEBUG("Timeout expired when sending a 'PREDECESSOR_LEAVING' to my successor %d", fingers_[0]);
     delete pred_msg;
   }
 
   if (pred_id_ != -1 && pred_id_ != id_) {
     // send the SUCCESSOR_LEAVING to our predecessor (only if I have one that is not me)
-    ChordMessage* succ_msg = new ChordMessage(SUCCESSOR_LEAVING);
+    auto* succ_msg         = new ChordMessage(SUCCESSOR_LEAVING);
     succ_msg->request_id   = fingers_[0];
     succ_msg->answer_to    = mailbox_;
     XBT_DEBUG("Sending a 'SUCCESSOR_LEAVING' to my predecessor %d", pred_id_);
 
     try {
       simgrid::s4u::Mailbox::by_name(std::to_string(pred_id_))->put(succ_msg, 10, timeout);
-    } catch (const simgrid::TimeoutError&) {
+    } catch (const simgrid::TimeoutException&) {
       XBT_DEBUG("Timeout expired when sending a 'SUCCESSOR_LEAVING' to my predecessor %d", pred_id_);
       delete succ_msg;
     }
@@ -135,7 +136,7 @@ void Node::notifyAndQuit()
 void Node::randomLookup()
 {
   int res          = id_;
-  int random_index = RngStream_RandInt(stream, 0, nb_bits - 1);
+  int random_index = random.uniform_int(0, nb_bits - 1);
   int random_id    = fingers_[random_index];
   XBT_DEBUG("Making a lookup request for id %d", random_id);
   if (random_id != id_)
@@ -207,14 +208,14 @@ void Node::checkPredecessor()
   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);
+  auto* message         = new ChordMessage(PREDECESSOR_ALIVE);
   message->request_id   = pred_id_;
   message->answer_to    = return_mailbox;
 
   XBT_DEBUG("Sending a 'Predecessor Alive' request to my predecessor %d", pred_id_);
   try {
     mailbox->put(message, 10, timeout);
-  } catch (const simgrid::TimeoutError&) {
+  } catch (const simgrid::TimeoutException&) {
     XBT_DEBUG("Failed to send the 'Predecessor Alive' request to %d", pred_id_);
     delete message;
     return;
@@ -229,7 +230,7 @@ void Node::checkPredecessor()
     comm->wait_for(timeout);
     XBT_DEBUG("Received the answer to my 'Predecessor Alive': my predecessor %d is alive", pred_id_);
     delete static_cast<ChordMessage*>(data);
-  } catch (const simgrid::TimeoutError&) {
+  } catch (const simgrid::TimeoutException&) {
     XBT_DEBUG("Failed to receive the answer to my 'Predecessor Alive' request");
     pred_id_ = -1;
   }
@@ -247,7 +248,7 @@ int Node::remoteGetPredecessor(int ask_to)
   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);
+  auto* message         = new ChordMessage(GET_PREDECESSOR);
   message->request_id   = id_;
   message->answer_to    = return_mailbox;
 
@@ -255,7 +256,7 @@ int Node::remoteGetPredecessor(int ask_to)
   XBT_DEBUG("Sending a 'Get Predecessor' request to %d", ask_to);
   try {
     mailbox->put(message, 10, timeout);
-  } catch (const simgrid::TimeoutError&) {
+  } catch (const simgrid::TimeoutException&) {
     XBT_DEBUG("Failed to send the 'Get Predecessor' request to %d", ask_to);
     delete message;
     return predecessor_id;
@@ -268,12 +269,12 @@ int Node::remoteGetPredecessor(int ask_to)
 
   try {
     comm->wait_for(timeout);
-    ChordMessage* answer = static_cast<ChordMessage*>(data);
+    const auto* answer = static_cast<ChordMessage*>(data);
     XBT_DEBUG("Received the answer to my 'Get Predecessor' request: the predecessor of node %d is %d", ask_to,
               answer->answer_id);
     predecessor_id = answer->answer_id;
     delete answer;
-  } catch (const simgrid::TimeoutError&) {
+  } catch (const simgrid::TimeoutException&) {
     XBT_DEBUG("Failed to receive the answer to my 'Get Predecessor' request");
     delete static_cast<ChordMessage*>(data);
   }
@@ -315,11 +316,11 @@ int Node::findSuccessor(int id)
 int Node::remoteFindSuccessor(int ask_to, int id)
 {
   int successor                           = -1;
-  void* data                              = nullptr;
+  ChordMessage* data                      = nullptr;
   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);
+  auto* message         = new ChordMessage(FIND_SUCCESSOR);
   message->request_id   = id_;
   message->answer_to    = return_mailbox;
 
@@ -327,25 +328,25 @@ int Node::remoteFindSuccessor(int ask_to, int id)
   XBT_DEBUG("Sending a 'Find Successor' request to %d for id %d", ask_to, id);
   try {
     mailbox->put(message, 10, timeout);
-  } catch (const simgrid::TimeoutError&) {
+  } catch (const simgrid::TimeoutException&) {
     XBT_DEBUG("Failed to send the 'Find Successor' request to %d for id %d", ask_to, id_);
     delete message;
     return successor;
   }
   // receive the answer
   XBT_DEBUG("Sent a 'Find Successor' request to %d for key %d, waiting for the answer", ask_to, id);
-  simgrid::s4u::CommPtr comm = return_mailbox->get_async(&data);
+  simgrid::s4u::CommPtr comm = return_mailbox->get_async(reinterpret_cast<void**>(&data));
 
   try {
     comm->wait_for(timeout);
-    ChordMessage* answer = static_cast<ChordMessage*>(data);
+    const ChordMessage* answer = data;
     XBT_DEBUG("Received the answer to my 'Find Successor' request for id %d: the successor of key %d is %d",
               answer->request_id, id_, answer->answer_id);
     successor = answer->answer_id;
     delete answer;
-  } catch (const simgrid::TimeoutError&) {
+  } catch (const simgrid::TimeoutException&) {
     XBT_DEBUG("Failed to receive the answer to my 'Find Successor' request");
-    delete static_cast<ChordMessage*>(data);
+    delete data;
   }
 
   return successor;
@@ -363,9 +364,9 @@ void Node::notify(int predecessor_candidate_id)
 }
 
 /* Notifies a remote node that its predecessor may have changed. */
-void Node::remoteNotify(int notify_id, int predecessor_candidate_id)
+void Node::remoteNotify(int notify_id, int predecessor_candidate_id) const
 {
-  ChordMessage* message = new ChordMessage(NOTIFY);
+  auto* message         = new ChordMessage(NOTIFY);
   message->request_id   = predecessor_candidate_id;
   message->answer_to    = nullptr;
 
@@ -475,3 +476,77 @@ void Node::handleMessage(ChordMessage* message)
     delete message;
   }
 }
+
+void Node::operator()()
+{
+  simgrid::s4u::this_actor::sleep_for(start_time_);
+  if (known_id_ == -1) {
+    setPredecessor(-1); // -1 means that I have no predecessor
+    printFingerTable();
+    joined = true;
+  } else {
+    join(known_id_);
+  }
+
+  if (not joined)
+    return;
+  void* data                         = nullptr;
+  double now                         = simgrid::s4u::Engine::get_clock();
+  double next_stabilize_date         = start_time_ + PERIODIC_STABILIZE_DELAY;
+  double next_fix_fingers_date       = start_time_ + PERIODIC_FIX_FINGERS_DELAY;
+  double next_check_predecessor_date = start_time_ + PERIODIC_CHECK_PREDECESSOR_DELAY;
+  double next_lookup_date            = start_time_ + PERIODIC_LOOKUP_DELAY;
+  simgrid::s4u::CommPtr comm_receive = nullptr;
+  while (now < std::min(start_time_ + deadline_, MAX_SIMULATION_TIME)) {
+    if (comm_receive == nullptr)
+      comm_receive = mailbox_->get_async(&data);
+    bool comm_completed = true;
+    try {
+      if (not comm_receive->test())
+        comm_completed = false;
+    } catch (const simgrid::TimeoutException&) {
+      XBT_DEBUG("Caught a timeout, go ahead.");
+    }
+
+    if (comm_completed) {
+      if (data != nullptr) {
+        auto* message = static_cast<ChordMessage*>(data);
+        handleMessage(message);
+        data = nullptr;
+      }
+      comm_receive = nullptr;
+    } else {
+      // no task was received: make some periodic calls
+      if (now >= next_stabilize_date) {
+        stabilize();
+        next_stabilize_date = simgrid::s4u::Engine::get_clock() + PERIODIC_STABILIZE_DELAY;
+      } else if (now >= next_fix_fingers_date) {
+        fixFingers();
+        next_fix_fingers_date = simgrid::s4u::Engine::get_clock() + PERIODIC_FIX_FINGERS_DELAY;
+      } else if (now >= next_check_predecessor_date) {
+        checkPredecessor();
+        next_check_predecessor_date = simgrid::s4u::Engine::get_clock() + PERIODIC_CHECK_PREDECESSOR_DELAY;
+      } else if (now >= next_lookup_date) {
+        randomLookup();
+        next_lookup_date = simgrid::s4u::Engine::get_clock() + PERIODIC_LOOKUP_DELAY;
+      } else {
+        // nothing to do: sleep for a while
+        simgrid::s4u::this_actor::sleep_for(SLEEP_DELAY);
+      }
+    }
+
+    now = simgrid::s4u::Engine::get_clock();
+  }
+  if (comm_receive != nullptr) {
+    try {
+      if (comm_receive->test())
+        delete static_cast<ChordMessage*>(data);
+      else
+        comm_receive->cancel();
+    } catch (const simgrid::TimeoutException&) {
+      XBT_DEBUG("Caught a timeout for last message, nevermind.");
+    }
+  }
+  // leave the ring
+  leave();
+}