mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-19 08:37:54 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Using microseconds in FakeNetworkPipe.

Browse source 
This CL changes the usages of milliseconds as a unit in FakeNetworkPipe
to microseconds. This matches the time unit of the PacketTime struct and
increases the precision of the simulation. The time resolution in
FakeNetworkPipe::Config is kept unchanged to keep the values more human
readable.

This CL prepares refactoring in upcoming CLs.

Bug: webrtc:9054
Change-Id: I103f7a0afa41381f676ea07fcc8c083532e61f1d
Reviewed-on: https://webrtc-review.googlesource.com/64140
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Christoffer Rodbro <crodbro@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23018}
This commit is contained in:
Sebastian Jansson 2018-04-23 13:15:04 +02:00 committed by Commit Bot
parent 09408115cd
commit 512bdce714
2 changed files with 62 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

105
call/fake_network_pipe.cc
View file

@ -25,6 +25,7 @@ namespace webrtc {
namespace { namespace {
constexpr int64_t kDefaultProcessIntervalMs = 5; constexpr int64_t kDefaultProcessIntervalMs = 5;
constexpr int64_t kLogIntervalMs = 5000;
struct PacketArrivalTimeComparator { struct PacketArrivalTimeComparator {
bool operator()(const NetworkPacket& p1, const NetworkPacket& p2) { bool operator()(const NetworkPacket& p1, const NetworkPacket& p2) {
return p1.arrival_time() < p2.arrival_time(); return p1.arrival_time() < p2.arrival_time();
@ -89,10 +90,10 @@ FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
config_(), config_(),
dropped_packets_(0), dropped_packets_(0),
sent_packets_(0), sent_packets_(0),
total_packet_delay_(0), total_packet_delay_us_(0),
bursting_(false), bursting_(false),
next_process_time_(clock_->TimeInMilliseconds()), next_process_time_us_(clock_->TimeInMicroseconds()),
last_log_time_(clock_->TimeInMilliseconds()) { last_log_time_us_(clock_->TimeInMicroseconds()) {
SetConfig(config); SetConfig(config);
} }
@ -107,10 +108,10 @@ FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
config_(), config_(),
dropped_packets_(0), dropped_packets_(0),
sent_packets_(0), sent_packets_(0),
total_packet_delay_(0), total_packet_delay_us_(0),
bursting_(false), bursting_(false),
next_process_time_(clock_->TimeInMilliseconds()), next_process_time_us_(clock_->TimeInMicroseconds()),
last_log_time_(clock_->TimeInMilliseconds()) { last_log_time_us_(clock_->TimeInMicroseconds()) {
SetConfig(config); SetConfig(config);
} }
@ -193,12 +194,13 @@ bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
return false; return false;
} }
int64_t time_now = clock_->TimeInMilliseconds(); int64_t time_now_us = clock_->TimeInMicroseconds();
// Delay introduced by the link capacity. // Delay introduced by the link capacity.
int64_t capacity_delay_ms = 0; int64_t capacity_delay_ms = 0;
if (config.link_capacity_kbps > 0) { if (config.link_capacity_kbps > 0) {
const int bytes_per_millisecond = config.link_capacity_kbps / 8; // Using bytes per millisecond to avoid losing precision.
const int64_t bytes_per_millisecond = config.link_capacity_kbps / 8;
// To round to the closest millisecond we add half a milliseconds worth of // To round to the closest millisecond we add half a milliseconds worth of
// bytes to the delay calculation. // bytes to the delay calculation.
capacity_delay_ms = (packet.size() + capacity_delay_error_bytes_ + capacity_delay_ms = (packet.size() + capacity_delay_error_bytes_ +
@ -207,17 +209,17 @@ bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
capacity_delay_error_bytes_ += capacity_delay_error_bytes_ +=
packet.size() - capacity_delay_ms * bytes_per_millisecond; packet.size() - capacity_delay_ms * bytes_per_millisecond;
} }
int64_t network_start_time = time_now; int64_t network_start_time_us = time_now_us;
// Check if there already are packets on the link and change network start // Check if there already are packets on the link and change network start
// time forward if there is. // time forward if there is.
if (!capacity_link_.empty() && if (!capacity_link_.empty() &&
network_start_time < capacity_link_.back().arrival_time()) network_start_time_us < capacity_link_.back().arrival_time())
network_start_time = capacity_link_.back().arrival_time(); network_start_time_us = capacity_link_.back().arrival_time();
int64_t arrival_time = network_start_time + capacity_delay_ms; int64_t arrival_time_us = network_start_time_us + capacity_delay_ms * 1000;
capacity_link_.emplace(std::move(packet), time_now, arrival_time, options, capacity_link_.emplace(std::move(packet), time_now_us, arrival_time_us,
is_rtcp, media_type, packet_time); options, is_rtcp, media_type, packet_time);
return true; return true;
} }
@ -235,8 +237,8 @@ int FakeNetworkPipe::AverageDelay() {
if (sent_packets_ == 0) if (sent_packets_ == 0)
return 0; return 0;
return static_cast<int>(total_packet_delay_ / return static_cast<int>(total_packet_delay_us_ /
static_cast<int64_t>(sent_packets_)); (1000 * static_cast<int64_t>(sent_packets_)));
} }
size_t FakeNetworkPipe::DroppedPackets() { size_t FakeNetworkPipe::DroppedPackets() {
@ -250,7 +252,7 @@ size_t FakeNetworkPipe::SentPackets() {
} }
void FakeNetworkPipe::Process() { void FakeNetworkPipe::Process() {
int64_t time_now = clock_->TimeInMilliseconds(); int64_t time_now_us = clock_->TimeInMicroseconds();
std::queue<NetworkPacket> packets_to_deliver; std::queue<NetworkPacket> packets_to_deliver;
Config config; Config config;
double prob_loss_bursting; double prob_loss_bursting;
@ -263,22 +265,22 @@ void FakeNetworkPipe::Process() {
} }
{ {
rtc::CritScope crit(&process_lock_); rtc::CritScope crit(&process_lock_);
if (time_now - last_log_time_ > 5000) { if (time_now_us - last_log_time_us_ > kLogIntervalMs * 1000) {
int64_t queueing_delay_ms = 0; int64_t queueing_delay_us = 0;
if (!capacity_link_.empty()) { if (!capacity_link_.empty()) {
queueing_delay_ms = time_now - capacity_link_.front().send_time(); queueing_delay_us = time_now_us - capacity_link_.front().send_time();
} }
RTC_LOG(LS_INFO) << "Network queue: " << queueing_delay_ms << " ms."; RTC_LOG(LS_INFO) << "Network queue: " << queueing_delay_us << " us.";
last_log_time_ = time_now; last_log_time_us_ = time_now_us;
} }
// Check the capacity link first. // Check the capacity link first.
if (!capacity_link_.empty()) { if (!capacity_link_.empty()) {
int64_t last_arrival_time = int64_t last_arrival_time_us =
delay_link_.empty() ? -1 : delay_link_.back().arrival_time(); delay_link_.empty() ? -1 : delay_link_.back().arrival_time();
bool needs_sort = false; bool needs_sort = false;
while (!capacity_link_.empty() && while (!capacity_link_.empty() &&
time_now >= capacity_link_.front().arrival_time()) { time_now_us >= capacity_link_.front().arrival_time()) {
// Time to get this packet. // Time to get this packet.
NetworkPacket packet = std::move(capacity_link_.front()); NetworkPacket packet = std::move(capacity_link_.front());
capacity_link_.pop(); capacity_link_.pop();
@ -293,18 +295,21 @@ void FakeNetworkPipe::Process() {
bursting_ = false; bursting_ = false;
} }
int arrival_time_jitter = random_.Gaussian( int64_t arrival_time_jitter_us =
config.queue_delay_ms, config.delay_standard_deviation_ms); random_.Gaussian(config.queue_delay_ms,
config.delay_standard_deviation_ms) *
1000;
// If reordering is not allowed then adjust arrival_time_jitter // If reordering is not allowed then adjust arrival_time_jitter
// to make sure all packets are sent in order. // to make sure all packets are sent in order.
if (!config.allow_reordering && !delay_link_.empty() && if (!config.allow_reordering && !delay_link_.empty() &&
packet.arrival_time() + arrival_time_jitter < last_arrival_time) { packet.arrival_time() + arrival_time_jitter_us <
arrival_time_jitter = last_arrival_time - packet.arrival_time(); last_arrival_time_us) {
arrival_time_jitter_us = last_arrival_time_us - packet.arrival_time();
} }
packet.IncrementArrivalTime(arrival_time_jitter); packet.IncrementArrivalTime(arrival_time_jitter_us);
if (packet.arrival_time() >= last_arrival_time) { if (packet.arrival_time() >= last_arrival_time_us) {
last_arrival_time = packet.arrival_time(); last_arrival_time_us = packet.arrival_time();
} else { } else {
needs_sort = true; needs_sort = true;
} }
@ -320,14 +325,14 @@ void FakeNetworkPipe::Process() {
// Check the extra delay queue. // Check the extra delay queue.
while (!delay_link_.empty() && while (!delay_link_.empty() &&
time_now >= delay_link_.front().arrival_time()) { time_now_us >= delay_link_.front().arrival_time()) {
// Deliver this packet. // Deliver this packet.
NetworkPacket packet(std::move(delay_link_.front())); NetworkPacket packet(std::move(delay_link_.front()));
delay_link_.pop_front(); delay_link_.pop_front();
// |time_now| might be later than when the packet should have arrived, due // |time_now| might be later than when the packet should have arrived, due
// to NetworkProcess being called too late. For stats, use the time it // to NetworkProcess being called too late. For stats, use the time it
// should have been on the link. // should have been on the link.
total_packet_delay_ += packet.arrival_time() - packet.send_time(); total_packet_delay_us_ += packet.arrival_time() - packet.send_time();
packets_to_deliver.push(std::move(packet)); packets_to_deliver.push(std::move(packet));
} }
sent_packets_ += packets_to_deliver.size(); sent_packets_ += packets_to_deliver.size();
@ -340,9 +345,9 @@ void FakeNetworkPipe::Process() {
DeliverPacket(&packet); DeliverPacket(&packet);
} }
next_process_time_ = !delay_link_.empty() next_process_time_us_ = !delay_link_.empty()
? delay_link_.begin()->arrival_time() ? delay_link_.begin()->arrival_time()
: time_now + kDefaultProcessIntervalMs; : time_now_us + kDefaultProcessIntervalMs * 1000;
} }
void FakeNetworkPipe::DeliverPacket(NetworkPacket* packet) { void FakeNetworkPipe::DeliverPacket(NetworkPacket* packet) {
@ -357,9 +362,9 @@ void FakeNetworkPipe::DeliverPacket(NetworkPacket* packet) {
} else if (receiver_) { } else if (receiver_) {
PacketTime packet_time = packet->packet_time(); PacketTime packet_time = packet->packet_time();
if (packet_time.timestamp != -1) { if (packet_time.timestamp != -1) {
int64_t queue_time = packet->arrival_time() - packet->send_time(); int64_t queue_time_us = packet->arrival_time() - packet->send_time();
RTC_CHECK(queue_time >= 0); RTC_CHECK(queue_time_us >= 0);
packet_time.timestamp += (queue_time * 1000); packet_time.timestamp += queue_time_us;
packet_time.timestamp += (clock_offset_ms_ * 1000); packet_time.timestamp += (clock_offset_ms_ * 1000);
} }
receiver_->DeliverPacket(packet->media_type(), receiver_->DeliverPacket(packet->media_type(),
@ -369,8 +374,8 @@ void FakeNetworkPipe::DeliverPacket(NetworkPacket* packet) {
int64_t FakeNetworkPipe::TimeUntilNextProcess() { int64_t FakeNetworkPipe::TimeUntilNextProcess() {
rtc::CritScope crit(&process_lock_); rtc::CritScope crit(&process_lock_);
return std::max<int64_t>(next_process_time_ - clock_->TimeInMilliseconds(), int64_t delay_us = next_process_time_us_ - clock_->TimeInMicroseconds();
0); return std::max<int64_t>((delay_us + 500) / 1000, 0);
} }
bool FakeNetworkPipe::HasTransport() const { bool FakeNetworkPipe::HasTransport() const {
@ -391,7 +396,7 @@ void FakeNetworkPipe::ResetStats() {
rtc::CritScope crit(&process_lock_); rtc::CritScope crit(&process_lock_);
dropped_packets_ = 0; dropped_packets_ = 0;
sent_packets_ = 0; sent_packets_ = 0;
total_packet_delay_ = 0; total_packet_delay_us_ = 0;
} }
int FakeNetworkPipe::GetConfigCapacityKbps() const { int FakeNetworkPipe::GetConfigCapacityKbps() const {
@ -409,25 +414,25 @@ void FakeNetworkPipe::AddToPacketSentCount(int count) {
sent_packets_ += count; sent_packets_ += count;
} }
void FakeNetworkPipe::AddToTotalDelay(int delay_ms) { void FakeNetworkPipe::AddToTotalDelay(int delay_us) {
rtc::CritScope crit(&process_lock_); rtc::CritScope crit(&process_lock_);
total_packet_delay_ += delay_ms; total_packet_delay_us_ += delay_us;
} }
int64_t FakeNetworkPipe::GetTimeInMilliseconds() const { int64_t FakeNetworkPipe::GetTimeInMicroseconds() const {
return clock_->TimeInMilliseconds(); return clock_->TimeInMicroseconds();
} }
bool FakeNetworkPipe::IsRandomLoss(double prob_loss) { bool FakeNetworkPipe::IsRandomLoss(double prob_loss) {
return random_.Rand<double>() < prob_loss; return random_.Rand<double>() < prob_loss;
} }
bool FakeNetworkPipe::ShouldProcess(int64_t time_now) const { bool FakeNetworkPipe::ShouldProcess(int64_t time_now_us) const {
return time_now >= next_process_time_; return time_now_us >= next_process_time_us_;
} }
void FakeNetworkPipe::SetTimeToNextProcess(int64_t skip_ms) { void FakeNetworkPipe::SetTimeToNextProcess(int64_t skip_us) {
next_process_time_ += skip_ms; next_process_time_us_ += skip_us;
} }
} // namespace webrtc } // namespace webrtc

14
call/fake_network_pipe.h
View file

@ -168,11 +168,11 @@ class FakeNetworkPipe : public Transport, public PacketReceiver, public Module {
int GetConfigCapacityKbps() const; int GetConfigCapacityKbps() const;
void AddToPacketDropCount(); void AddToPacketDropCount();
void AddToPacketSentCount(int count); void AddToPacketSentCount(int count);
void AddToTotalDelay(int delay_ms); void AddToTotalDelay(int delay_us);
int64_t GetTimeInMilliseconds() const; int64_t GetTimeInMicroseconds() const;
bool IsRandomLoss(double prob_loss); bool IsRandomLoss(double prob_loss);
bool ShouldProcess(int64_t time_now) const; bool ShouldProcess(int64_t time_now_us) const;
void SetTimeToNextProcess(int64_t skip_ms); void SetTimeToNextProcess(int64_t skip_us);
private: private:
// Returns true if enqueued, or false if packet was dropped. // Returns true if enqueued, or false if packet was dropped.
@ -208,7 +208,7 @@ class FakeNetworkPipe : public Transport, public PacketReceiver, public Module {
// Statistics. // Statistics.
size_t dropped_packets_ RTC_GUARDED_BY(process_lock_); size_t dropped_packets_ RTC_GUARDED_BY(process_lock_);
size_t sent_packets_ RTC_GUARDED_BY(process_lock_); size_t sent_packets_ RTC_GUARDED_BY(process_lock_);
int64_t total_packet_delay_ RTC_GUARDED_BY(process_lock_); int64_t total_packet_delay_us_ RTC_GUARDED_BY(process_lock_);
// Are we currently dropping a burst of packets? // Are we currently dropping a burst of packets?
bool bursting_; bool bursting_;
@ -220,9 +220,9 @@ class FakeNetworkPipe : public Transport, public PacketReceiver, public Module {
// The probability to drop a burst of packets. // The probability to drop a burst of packets.
double prob_start_bursting_ RTC_GUARDED_BY(config_lock_); double prob_start_bursting_ RTC_GUARDED_BY(config_lock_);
int64_t next_process_time_; int64_t next_process_time_us_;
int64_t last_log_time_; int64_t last_log_time_us_;
int64_t capacity_delay_error_bytes_ = 0; int64_t capacity_delay_error_bytes_ = 0;