minor bugfixes. trying to get the simulator to work

Author: anderspkd

include/scl/simulation/context.h

@@ -19,6 +19,7 @@
 
 #include <cstddef>
 #include <type_traits>
+#include <iostream>
 
 #include "scl/simulation/event.h"
 #include "scl/simulation/network_description.h"
@@ -96,6 +97,10 @@ class SimulatorContext final {
     return m_network_desc.size();
   }
 
+  Simulator::Result toResult() {
+    return Simulator::Result{std::move(m_events)};
+  }
+
  private:
   NetworkDescription m_network_desc;
   std::vector<EventList> m_events;

include/scl/simulation/event.h

@@ -410,8 +410,6 @@ class SleepEvent final : public Event {
   Time::Duration m_duration;
 };
 
-namespace details {
-
 /**
  * @brief Tracks events added by a party during simulation.
  *
@@ -474,5 +472,4 @@ class EventList final {
   std::vector<std::unique_ptr<Event>> m_events;
 };
 
-}  // namespace details
 }  // namespace scl

include/scl/simulation/runtime.h

@@ -32,7 +32,8 @@ class SimulatorRuntime final : public Runtime {
   static const std::size_t MANAGE_PID = static_cast<std::size_t>(-1);
 
  public:
-  SimulatorRuntime(SimulatorContext& sim_ctx) : m_sim_ctx(sim_ctx) {}
+  SimulatorRuntime(SimulatorContext& sim_ctx)
+      : m_sim_ctx(sim_ctx), m_current_pid(MANAGE_PID) {}
 
   void schedule(std::coroutine_handle<> coroutine,
                 std::function<bool()>&& predicate) override;

include/scl/simulation/simulator.h

@@ -45,6 +45,19 @@ concept ProtocolBuilder = requires(BUILDER builder) {
  */
 class Simulator final {
  public:
+  class Result final {
+   public:
+    Result(std::vector<EventList>&& events) : m_events(std::move(events)) {}
+    std::size_t numberOfParties() const {
+      return m_events.size();
+    }
+    EventList& operator[](std::size_t i) {
+      return m_events[i];
+    }
+
+   private:
+    std::vector<EventList> m_events;
+  };
   /**
    * @brief A simulation hook.
    *
@@ -66,7 +79,7 @@ class Simulator final {
    * sim.addHook(EventType::BEGIN_EVENT, printHook);
    * @endcode
    */
-  struct SimulationHook {
+  struct SimulationHook final {
     /**
      * @brief Type definition of hook functions.
      */
@@ -87,12 +100,12 @@ class Simulator final {
    * @brief Run the simulation.
    */
   template <ProtocolBuilder BUILDER>
-  void run(BUILDER builder, NetworkDescription network_desc) {
+  Result run(BUILDER builder, NetworkDescription network_desc) {
     auto protocol = builder();
     if (protocol.size() != network_desc.size()) {
       throw std::logic_error("protocols do not match network definition");
     }
-    run(std::move(protocol), network_desc);
+    return run(std::move(protocol), network_desc);
   }
 
   /**
@@ -116,8 +129,8 @@ class Simulator final {
  private:
   std::vector<SimulationHook> m_hooks;
 
-  void run(std::vector<std::unique_ptr<Protocol>>&& protocols,
-           NetworkDescription network_desc);
+  Result run(std::vector<std::unique_ptr<Protocol>>&& protocols,
+             NetworkDescription network_desc);
 };
 
 }  // namespace scl

include/scl/time.h

@@ -48,8 +48,7 @@ struct Time {
  * @brief Convert a timestamp to milliseconds.
  */
 inline long double timeToMillis(Time::Duration time) {
-  using namespace std::chrono;
-  return duration<long double, std::milli>(time).count();
+  return std::chrono::duration<long double, std::milli>(time).count();
 }
 
 /**

src/scl/simulation/channel.cc

@@ -25,9 +25,6 @@
 
 using namespace scl;
 
-// This suspends a coroutine, while enabling it to be resumed again at any time.
-#define SUSPEND co_await []() { return true; }
-
 void details::SimulatedChannel::close() {
   if (!m_closed) {
     m_ctx.addEvent<CloseEvent>(m_ctx.elapsedTime(), m_id);
@@ -87,7 +84,9 @@ Task<void> waitForData(details::Transport* transport,
     const auto diff = std::max(ctx.elapsedTimeOf(id.remote) - event->time(),
                                Time::Duration::zero());
     event->increaseOffset(diff);
-    SUSPEND;
+
+    // Suspend this coroutine.
+    co_await []() { return true; };
   }
 }
 
@@ -128,7 +127,7 @@ Task<bool> waitOrTimeout(details::Transport* transport,
 
       if (stime >= event->time()) {
         // sender_time >= our_time. Two cases, based on how far ahead the sender
-        // is of us.
+        // is relative to us.
         //
         //          |---------- time ----------|
         //            |          |          |
@@ -138,8 +137,8 @@ Task<bool> waitOrTimeout(details::Transport* transport,
         // In the first case, we know that we're gonna timeout, so we can
         // advance our clock to the timeout mark, and return true.
         //
-        // In the second case, we can advance our clock a little bit (see the
-        // bumpTime function) and then suspend. We need to move our clock a
+        // In the second case, we can advance our clock a little bit (the
+        // timeout_wait_interval) and then suspend. We need to move our clock a
         // little bit to avoid deadlocks.
 
         if (stime > event->time() + timeout) {
@@ -153,7 +152,8 @@ Task<bool> waitOrTimeout(details::Transport* transport,
         timeout -= timeout_wait_interval;
       }
 
-      SUSPEND;
+      // Suspend this coroutine.
+      co_await []() { return true; };
     }
 
     // there is data available within the timeout

src/scl/simulation/event.cc

@@ -31,6 +31,10 @@ void writeNumeric(std::ostream& stream, std::string_view key, std::size_t n) {
   stream << "\"" << key << "\":" << n;
 }
 
+void writeNumeric(std::ostream& stream, std::string_view key, long double n) {
+  stream << "\"" << key << "\":" << n;
+}
+
 void writeString(std::ostream& stream,
                  std::string_view key,
                  std::string_view val) {
@@ -195,6 +199,6 @@ struct InitialEvent final : public Event {
 
 }  // namespace
 
-details::EventList::EventList() {
+EventList::EventList() {
   add<InitialEvent>();
 }

src/scl/simulation/network_description.cc

@@ -31,6 +31,11 @@ const ChannelDescription DEFAULT_LAN_PARAMS = {.bandwith = 100000000000,
                                                .latency_jitter = 0,
                                                .loss = 0.0};
 
+const ChannelDescription DEFAULT_WAN_PARAMS = {.bandwith = 1000000000,
+                                               .latency = 10000,
+                                               .latency_jitter = 0,
+                                               .loss = 0.0};
+
 const ChannelDescription DEFAULT_LOCAL_PARAMS = {
     .bandwith = std::numeric_limits<std::size_t>::max(),
     .latency = 0,
@@ -52,6 +57,21 @@ NetworkDescription NetworkDescription::createDefaultLAN(std::size_t size) {
   return NetworkDescription{channels, ignored, size};
 }
 
+NetworkDescription NetworkDescription::createDefaultWAN(std::size_t size) {
+  std::unordered_map<ChannelId, ChannelDescription> channels;
+  std::unordered_map<ChannelId, JitterSampler> ignored;
+
+  for (std::size_t i = 0; i < size; i++) {
+    channels[ChannelId(i, i)] = DEFAULT_LOCAL_PARAMS;
+    for (std::size_t j = i + 1; j < size; j++) {
+      channels[ChannelId(i, j)] = DEFAULT_WAN_PARAMS;
+      channels[ChannelId(j, i)] = DEFAULT_WAN_PARAMS;
+    }
+  }
+
+  return NetworkDescription{channels, ignored, size};
+}
+
 NetworkDescription::ChannelParameters descriptionToParams(
     const ChannelDescription& desc) {
   return NetworkDescription::ChannelParameters{.bandwidth = desc.bandwith,

src/scl/simulation/simulator.cc

@@ -18,6 +18,7 @@
 #include "scl/simulation/simulator.h"
 
 #include <algorithm>
+#include <iostream>
 #include <memory>
 
 #include "scl/net/loopback.h"
@@ -86,7 +87,7 @@ class ProtocolBatch final {
 // Main per-party protocol loop.
 Task<void> runProtocol(std::unique_ptr<Protocol> protocol,
                        details::Context ctx,
-                       Env&& env) {
+                       Env env) {
   // Executing a protocol for a party goes more or less as follows:
   // 1. Emit a START event
   // 2. Emit a BEGIN event (signals the beginning of a Protocol)
@@ -171,8 +172,8 @@ std::vector<Network> createNetworks(details::SimulatorContext& sim_ctx) {
   return networks;
 }
 
-// Clock implementation which will provide a party with a sensible value, when
-// called.
+// Ensures that parties get a sensible value when reading their clock in a
+// simulation.
 class FakeClock final : public Clock {
  public:
   FakeClock(details::Context ctx) : m_ctx(ctx) {}
@@ -199,18 +200,23 @@ Task<void> simulate(std::vector<std::unique_ptr<Protocol>>&& protocols,
                     Env{networks[pid], std::make_unique<FakeClock>(ctx)}));
   }
 
+  // runs the simulation.
   co_await ProtocolBatch(std::move(protocol_tasks));
 }
 
 }  // namespace
 
-void Simulator::run(std::vector<std::unique_ptr<Protocol>>&& protocols,
-                    NetworkDescription network_definition) {
+Simulator::Result Simulator::run(
+    std::vector<std::unique_ptr<Protocol>>&& protocols,
+    NetworkDescription network_definition) {
   if (!protocols.empty()) {
     auto sim_ctx = details::SimulatorContext::create(network_definition,
                                                      std::move(m_hooks));
     auto runtime = std::make_unique<details::SimulatorRuntime>(sim_ctx);
 
     runtime->run(simulate(std::move(protocols), sim_ctx));
+    return sim_ctx.toResult();
   }
+
+  return Simulator::Result({});
 }

src/scl/simulation/transport.cc

@@ -78,12 +78,6 @@ long double rttSeconds(std::size_t latency_us) {
   return std::chrono::microseconds(2 * latency_us) / 1.0s;
 }
 
-// Utility function that does the reverse of the above.
-Time::Duration convert(long double v) {
-  const auto t0 = std::chrono::duration<long double>(v);
-  return std::chrono::duration_cast<Time::Duration>(t0);
-}
-
 // calculate the throughput of a channel.
 long double throughput(NetworkDescription::ChannelParameters params) {
   const auto rtt_secs = rttSeconds(params.latency);
@@ -107,17 +101,23 @@ long double throughput(NetworkDescription::ChannelParameters params) {
   return std::min(tp, (long double)params.bandwidth);
 }
 
+// Utility function that does the reverse of the above.
+Time::Duration convert(long double v) {
+  const auto t0 = std::chrono::duration<long double>(v);
+  return std::chrono::duration_cast<Time::Duration>(t0);
+}
+
 // compute the time it takes to send n bytes on a channel.
 Time::Duration recvTimeOffset(std::size_t n,
                               NetworkDescription::ChannelParameters params) {
   const long double total_size = completeDataSize(n);
   const long double tp = throughput(params);
 
-  // the min here is needed in case we're sending very small amounts of
+  // the max here is needed in case we're sending very small amounts of
   // data. I.e., regardless of how good the channel is, we cannot send data
   // faster than the latency.
   const long double delay =
-      std::min(total_size / tp, rttSeconds(params.latency));
+      std::max(total_size / tp, rttSeconds(params.latency));
 
   return convert(delay);
 }
@@ -129,7 +129,9 @@ Time::Duration computeDelay(Time::Duration rt,
                             Time::Duration st,
                             std::size_t n,
                             NetworkDescription::ChannelParameters params) {
-  return std::max(st + recvTimeOffset(n, params) - rt, Time::Duration::zero());
+  const auto x = st + recvTimeOffset(n, params) - rt;
+  std::cout << recvTimeOffset(n, params) << "\n";
+  return std::max(x, Time::Duration::zero());
 }
 
 }  // namespace