more simulator stuff

Author: anderspkd

include/scl/simulation/context.h

@@ -19,10 +19,9 @@
 
 #include <cstddef>
 #include <type_traits>
-#include <iostream>
 
 #include "scl/simulation/event.h"
-#include "scl/simulation/network_description.h"
+#include "scl/simulation/params.h"
 #include "scl/simulation/simulator.h"
 
 namespace scl::details {
@@ -39,7 +38,8 @@ class SimulatorContext final {
    * @brief Create a new simulation context object.
    */
   static SimulatorContext create(
-      NetworkDescription network_desc,
+      std::size_t number_of_parties,
+      NetworkParams network_params,
       std::vector<Simulator::SimulationHook>&& hooks);
 
   /**
@@ -86,29 +86,30 @@ class SimulatorContext final {
   /**
    * @brief Get the channel parameters of a channel.
    */
-  NetworkDescription::ChannelParameters getChannel(ChannelId cid) {
-    return m_network_desc.getChannel(cid);
+  ChannelParams getChannel(ChannelId cid) {
+    return m_network_params.channel(cid);
   }
 
   /**
    * @brief Get the number of parties in this simulation.
    */
   std::size_t numberOfParties() const {
-    return m_network_desc.size();
+    return m_number_of_parties;
   }
 
   Simulator::Result toResult() {
     return Simulator::Result{std::move(m_events)};
   }
 
  private:
-  NetworkDescription m_network_desc;
+  std::size_t m_number_of_parties;
+  NetworkParams m_network_params;
   std::vector<EventList> m_events;
   std::vector<Time::TimePoint> m_clocks;
   std::vector<Simulator::SimulationHook> m_hooks;
 
-  SimulatorContext(NetworkDescription network_desc)
-      : m_network_desc(network_desc) {}
+  SimulatorContext(NetworkParams network_params)
+      : m_network_params(network_params) {}
 
   void runHooks(std::size_t pid, Event* event);
 };

include/scl/simulation/params.h

@@ -26,152 +26,134 @@
 
 namespace scl {
 
-class ChannelDesc final {
+/**
+ * @brief Provider for a communication channels paramters.
+ * @ingroup eval-sim
+ *
+ * A ChannelParams object describes the characteristics of a particular
+ * communication channel in terms of its bandwidth and latency.
+ *
+ * A communication channel is either "deterministic" or "probabilistic", with
+ * respect to its parameters. Concretely, either the channel's parameters are
+ * fixed or they are sampled from some distribution.
+ *
+ * Note that the packet loss of a channel is a (by its nature) probabilistic
+ * parameter regardless of the type of the other parameters.
+ *
+ * The units used is as follows:
+ * - bits per second for bandwidth.
+ * - microseconds for latency.
+ * - percentage, as a value between 0 and 1 for packet loss.
+ */
+class ChannelParams final {
  public:
-  ChannelDesc createDet(std::size_t bandwidth, std::size_t latency) {
-    return ChannelDesc(DetParams{bandwidth, latency});
+  /**
+   * @brief Create a deterministic channel description.
+   */
+  static ChannelParams createDet(std::size_t bandwidth,
+                                 std::size_t latency,
+                                 float packet_loss) {
+    return ChannelParams(DetParams{bandwidth, latency, packet_loss});
   }
-  ChannelDesc createProp(std::normal_distribution<> bandwidth,
-                         std::normal_distribution<> latency) {
+
+  /**
+   * @brief Create a probabilistic channel description.
+   */
+  static ChannelParams createProb(std::normal_distribution<> bandwidth,
+                                  std::normal_distribution<> latency,
+                                  float packet_loss) {
     std::random_device rd{};
     std::mt19937 rg{rd()};
-    return ChannelDesc(PropParams{rg, bandwidth, latency});
+    return ChannelParams(PropParams{rg, bandwidth, latency, packet_loss});
   }
 
+  ChannelParams() {}
+
+  /**
+   * @brief Bandwidth of the channel.
+   */
   std::size_t bandwidth();
+
+  /**
+   * @brief Latency of the channel.
+   */
   std::size_t latency();
 
+  /**
+   * @brief The packet loss percentage of this channel.
+   */
+  float packetLoss();
+
  private:
   struct DetParams final {
     std::size_t bandwidth;
     std::size_t latency;
+    float packet_loss;
   };
 
   struct PropParams final {
     std::mt19937 rg;
 
     std::normal_distribution<> bandwidth;
     std::normal_distribution<> latency;
+    float packet_loss;
   };
 
-  ChannelDesc(DetParams params) : m_params(params) {}
-  ChannelDesc(PropParams params) : m_params(params) {}
+  ChannelParams(DetParams params) : m_params{params} {}
+  ChannelParams(PropParams params) : m_params{params} {}
 
-  std::variant<DetParams, PropParams> m_params;
-};
-
-// TODO: Create a simplier, and more extensible network description. Potentially
-// shorten the name as well.
-//
-// The new object (interface shown below) should provide the "raw" link
-// bandwidth and latency on a given channel. I guess it is possible to
-// dynamically adjust the bandwidth of a channel depending on usage, but I think
-// that task is better done elsewhere (e.g., in the Transport).
-//
-// NetworkDesc:
-//   std::size_t latency(ChannelId cid);
-//   std::size_t bandwidth(ChannelId cid);
-//
-// ChannelDesc:
-//   virtual std::size_t latency();
-//   virtual std::size_t bandwidth();
-//
-// NetworkDesc is internally composed of a list of ChannelDesc. The definition
-// of ChannelDesc allows the user to either provide some constant value, or to
-// sample the value from a distribution.
-
-/**
- * @brief Describes the characterists of a channel.
- */
-struct ChannelDescription final {
-  /**
-   * @brief The channel bandwidth, in bits/s.
-   */
-  std::size_t bandwith;
-
-  /**
-   * @brief The channel latency, in microseconds.
-   */
-  std::size_t latency;
-
-  /**
-   * @brief The latency variance, in microseconds.
-   */
-  std::size_t latency_jitter;
+  bool deterministicChannel() const {
+    return m_params.index() == 0;
+  }
 
-  /**
-   * @brief The channel package loss, a value in [0, 1).
-   */
-  float loss;
+  std::variant<DetParams, PropParams> m_params;
 };
 
 /**
- * @brief Describes a network in terms of its channels.
+ * @brief A parameter collection for a network.
+ * @ingroup eval-sim
+ *
+ * NetworkParams can be viewed as a collection of ChannelParams (as that is what
+ * it ultimately is).
  */
-class NetworkDescription final {
+class NetworkParams final {
  public:
   /**
-   * @brief The parameters of a channel at a given point in time.
+   * @brief Create a set of network parameters with some sane defaults.
+   *
+   * This creates a new set of network parameters supporting a specified number
+   * of parties. The provided \p bandwidth and \p latency arguments determine
+   * the bandwidth and latency for all channels that are not "loopback"
+   * channels.
+   *
+   * The default values provide a sane "WAN"-like default of 1Mbps bandwidth,
+   * 50ms latency and 0.1% packet loss.
    */
-  struct ChannelParameters {
-    /**
-     * @brief The current channel bandwidth.
-     */
-    std::size_t bandwidth;
-
-    /**
-     * @brief The current channel latency.
-     */
-    std::size_t latency;
-
-    /**
-     * @brief The current channel packege loss.
-     */
-    float loss;
-  };
+  static NetworkParams create(std::size_t number_of_parties,
+                              std::size_t bandwidth = 1000000,
+                              std::size_t latency = 50000,
+                              float packet_loss = 0.01);
 
   /**
-   * @brief Create a default LAN network.
+   * @brief Read network parameters from a file.
    */
-  static NetworkDescription createDefaultLAN(std::size_t size);
+  static NetworkParams fromFile(const std::string& filename);
 
   /**
-   * @brief Create a default WAN network.
+   * @brief Construct network parameters from a set of channel parameters.
    */
-  static NetworkDescription createDefaultWAN(std::size_t size);
+  NetworkParams(const std::unordered_map<ChannelId, ChannelParams>& channels)
+      : m_channels(channels) {}
 
   /**
-   * @brief The size of the network.
+   * @brief Get the parameters of a channel.
    */
-  std::size_t size() const {
-    return m_size;
+  ChannelParams channel(ChannelId id) const {
+    return m_channels.at(id);
   }
 
-  /**
-   * @brief Get the parameters of a particular channel.
-   */
-  ChannelParameters getChannel(ChannelId id);
-
  private:
-  struct JitterSampler {
-    std::mt19937 rg;
-    std::normal_distribution<> dist;
-
-    std::size_t operator()() {
-      return std::lround(dist(rg));
-    }
-  };
-
-  std::unordered_map<ChannelId, ChannelDescription> m_channels;
-  std::unordered_map<ChannelId, JitterSampler> m_samplers;
-
-  std::size_t m_size;
-
-  NetworkDescription(
-      const std::unordered_map<ChannelId, ChannelDescription>& channels,
-      const std::unordered_map<ChannelId, JitterSampler>& samplers,
-      std::size_t size)
-      : m_channels(channels), m_samplers(samplers), m_size(size) {}
+  std::unordered_map<ChannelId, ChannelParams> m_channels;
 };
 
 }  // namespace scl

include/scl/simulation/runtime.h

@@ -32,6 +32,8 @@ class SimulatorRuntime final : public Runtime {
   static const std::size_t MANAGE_PID = static_cast<std::size_t>(-1);
 
  public:
+  using Runtime::schedule;
+
   SimulatorRuntime(SimulatorContext& sim_ctx)
       : m_sim_ctx(sim_ctx), m_current_pid(MANAGE_PID) {}
 

include/scl/simulation/simulator.h

@@ -20,17 +20,17 @@
 #include <concepts>
 #include <functional>
 #include <memory>
-#include <stdexcept>
 #include <vector>
 
 #include "scl/protocol.h"
 #include "scl/simulation/event.h"
-#include "scl/simulation/network_description.h"
+#include "scl/simulation/params.h"
 
 namespace scl {
 
 /**
  * @brief Concept for protocol builder objects.
+ * @ingroup eval-sim
  *
  * A "ProtocolBuilder" is any type which, when invoked, returns an std::vector
  * of Protocol objects.
@@ -42,22 +42,28 @@ concept ProtocolBuilder = requires(BUILDER builder) {
 
 /**
  * @brief The simulator.
+ * @ingroup eval-sim
  */
 class Simulator final {
  public:
+  /**
+   * @brief The result of a simulation.
+   */
   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.
    *
@@ -100,12 +106,9 @@ class Simulator final {
    * @brief Run the simulation.
    */
   template <ProtocolBuilder BUILDER>
-  Result run(BUILDER builder, NetworkDescription network_desc) {
+  Result run(BUILDER builder, NetworkParams network_params) {
     auto protocol = builder();
-    if (protocol.size() != network_desc.size()) {
-      throw std::logic_error("protocols do not match network definition");
-    }
-    return run(std::move(protocol), network_desc);
+    return run(std::move(protocol), network_params);
   }
 
   /**
@@ -130,7 +133,7 @@ class Simulator final {
   std::vector<SimulationHook> m_hooks;
 
   Result run(std::vector<std::unique_ptr<Protocol>>&& protocols,
-             NetworkDescription network_desc);
+             NetworkParams network_params);
 };
 
 }  // namespace scl

src/scl/simulation/channel.cc

@@ -52,8 +52,7 @@ namespace {
 // receiving.
 class RecvPendingEvent final : public ChannelEvent {
  public:
-  RecvPendingEvent(Time::Duration timestamp, ChannelId id)
-      : ChannelEvent(timestamp, id), m_offset(Time::Duration::zero()) {}
+  using ChannelEvent::ChannelEvent;
 
   void write(std::ostream&) override {}
 
@@ -70,7 +69,7 @@ class RecvPendingEvent final : public ChannelEvent {
   }
 
  private:
-  Time::Duration m_offset;
+  Time::Duration m_offset = Time::Duration::zero();
 };
 
 // Waits (i.e., suspends) until the transport has data ready for us