diff options
Diffstat (limited to 'third_party/libwebrtc/call/simulated_network.h')
-rw-r--r-- | third_party/libwebrtc/call/simulated_network.h | 134 |
1 files changed, 134 insertions, 0 deletions
diff --git a/third_party/libwebrtc/call/simulated_network.h b/third_party/libwebrtc/call/simulated_network.h new file mode 100644 index 0000000000..8597367add --- /dev/null +++ b/third_party/libwebrtc/call/simulated_network.h @@ -0,0 +1,134 @@ +/* + * Copyright 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ +#ifndef CALL_SIMULATED_NETWORK_H_ +#define CALL_SIMULATED_NETWORK_H_ + +#include <stdint.h> + +#include <deque> +#include <queue> +#include <vector> + +#include "absl/types/optional.h" +#include "api/sequence_checker.h" +#include "api/test/simulated_network.h" +#include "api/units/data_size.h" +#include "api/units/timestamp.h" +#include "rtc_base/race_checker.h" +#include "rtc_base/random.h" +#include "rtc_base/synchronization/mutex.h" +#include "rtc_base/thread_annotations.h" + +namespace webrtc { + +// Class simulating a network link. +// +// This is a basic implementation of NetworkBehaviorInterface that supports: +// - Packet loss +// - Capacity delay +// - Extra delay with or without packets reorder +// - Packet overhead +// - Queue max capacity +class SimulatedNetwork : public SimulatedNetworkInterface { + public: + using Config = BuiltInNetworkBehaviorConfig; + explicit SimulatedNetwork(Config config, uint64_t random_seed = 1); + ~SimulatedNetwork() override; + + // Sets a new configuration. This will affect packets that will be sent with + // EnqueuePacket but also packets in the network that have not left the + // network emulation. Packets that are ready to be retrieved by + // DequeueDeliverablePackets are not affected by the new configuration. + // TODO(bugs.webrtc.org/14525): Fix SetConfig and make it apply only to the + // part of the packet that is currently being sent (instead of applying to + // all of it). + void SetConfig(const Config& config) override; + void UpdateConfig(std::function<void(BuiltInNetworkBehaviorConfig*)> + config_modifier) override; + void PauseTransmissionUntil(int64_t until_us) override; + + // NetworkBehaviorInterface + bool EnqueuePacket(PacketInFlightInfo packet) override; + std::vector<PacketDeliveryInfo> DequeueDeliverablePackets( + int64_t receive_time_us) override; + + absl::optional<int64_t> NextDeliveryTimeUs() const override; + + private: + struct PacketInfo { + PacketInFlightInfo packet; + // Time when the packet has left (or will leave) the network. + int64_t arrival_time_us; + }; + // Contains current configuration state. + struct ConfigState { + // Static link configuration. + Config config; + // The probability to drop the packet if we are currently dropping a + // burst of packet + double prob_loss_bursting; + // The probability to drop a burst of packets. + double prob_start_bursting; + // Used for temporary delay spikes. + int64_t pause_transmission_until_us = 0; + }; + + // Moves packets from capacity- to delay link. + void UpdateCapacityQueue(ConfigState state, int64_t time_now_us) + RTC_RUN_ON(&process_checker_); + ConfigState GetConfigState() const; + + mutable Mutex config_lock_; + + // Guards the data structures involved in delay and loss processing, such as + // the packet queues. + rtc::RaceChecker process_checker_; + // Models the capacity of the network by rejecting packets if the queue is + // full and keeping them in the queue until they are ready to exit (according + // to the link capacity, which cannot be violated, e.g. a 1 kbps link will + // only be able to deliver 1000 bits per second). + // + // Invariant: + // The head of the `capacity_link_` has arrival_time_us correctly set to the + // time when the packet is supposed to be delivered (without accounting + // potential packet loss or potential extra delay and without accounting for a + // new configuration of the network, which requires a re-computation of the + // arrival_time_us). + std::queue<PacketInfo> capacity_link_ RTC_GUARDED_BY(process_checker_); + // Models the extra delay of the network (see `queue_delay_ms` + // and `delay_standard_deviation_ms` in BuiltInNetworkBehaviorConfig), packets + // in the `delay_link_` have technically already left the network and don't + // use its capacity but they are not delivered yet. + std::deque<PacketInfo> delay_link_ RTC_GUARDED_BY(process_checker_); + // Represents the next moment in time when the network is supposed to deliver + // packets to the client (either by pulling them from `delay_link_` or + // `capacity_link_` or both). + absl::optional<int64_t> next_process_time_us_ + RTC_GUARDED_BY(process_checker_); + + ConfigState config_state_ RTC_GUARDED_BY(config_lock_); + + Random random_ RTC_GUARDED_BY(process_checker_); + // Are we currently dropping a burst of packets? + bool bursting_; + + // The send time of the last enqueued packet, this is only used to check that + // the send time of enqueued packets is monotonically increasing. + int64_t last_enqueue_time_us_; + + // The last time a packet left the capacity_link_ (used to enforce + // the capacity of the link and avoid packets starts to get sent before + // the link it free). + int64_t last_capacity_link_exit_time_; +}; + +} // namespace webrtc + +#endif // CALL_SIMULATED_NETWORK_H_ |