admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrote pacer and bandwidth UMA stats.

Browse Source 
The new version measures receive bitrates from time of first packet to
time of last packet, and send/pacer BWE as the average BWE reported
while we have send streams.

R=asapersson@webrtc.org, pbos@webrtc.org

Review URL: https://codereview.webrtc.org/1470373004 .

Cr-Commit-Position: refs/heads/master@{#10810}
This commit is contained in:
Stefan Holmer 2015-11-26 15:36:48 +01:00
parent 06e05a85b9
commit 226befecfb
1 changed files with 35 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
webrtc/call/call.cc
View File

@ -114,7 +114,7 @@ class Call : public webrtc::Call, public PacketReceiver,
return nullptr;
}
void UpdateSendHistograms();
void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
void UpdateReceiveHistograms();
const Clock* const clock_;
@ -152,20 +152,19 @@ class Call : public webrtc::Call, public PacketReceiver,
// The following members are only accessed (exclusively) from one thread and
// from the destructor, and therefore doesn't need any explicit
// synchronization.
rtc::RateTracker received_video_bytes_per_sec_;
rtc::RateTracker received_audio_bytes_per_sec_;
rtc::RateTracker received_rtcp_bytes_per_sec_;
int64_t first_packet_sent_ms_;
int64_t received_video_bytes_;
int64_t received_audio_bytes_;
int64_t received_rtcp_bytes_;
int64_t first_rtp_packet_received_ms_;
int64_t last_rtp_packet_received_ms_;
int64_t first_packet_sent_ms_;
// TODO(holmer): Remove this lock once BitrateController no longer calls
// OnNetworkChanged from multiple threads.
rtc::CriticalSection bitrate_crit_;
rtc::RateTracker estimated_send_bitrate_kbps_ GUARDED_BY(&bitrate_crit_);
rtc::RateTracker pacer_bitrate_kbps_ GUARDED_BY(&bitrate_crit_);
uint32_t target_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
uint32_t pacer_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
int64_t last_bitrate_update_ms_ GUARDED_BY(&bitrate_crit_);
int64_t estimated_send_bitrate_sum_kbits_ GUARDED_BY(&bitrate_crit_);
int64_t pacer_bitrate_sum_kbits_ GUARDED_BY(&bitrate_crit_);
int64_t num_bitrate_updates_ GUARDED_BY(&bitrate_crit_);
const rtc::scoped_ptr<CongestionController> congestion_controller_;
@ -189,16 +188,15 @@ Call::Call(const Call::Config& config)
network_enabled_(true),
receive_crit_(RWLockWrapper::CreateRWLock()),
send_crit_(RWLockWrapper::CreateRWLock()),
received_video_bytes_per_sec_(1000, 1),
received_audio_bytes_per_sec_(1000, 1),
received_rtcp_bytes_per_sec_(1000, 1),
first_packet_sent_ms_(-1),
received_video_bytes_(0),
received_audio_bytes_(0),
received_rtcp_bytes_(0),
first_rtp_packet_received_ms_(-1),
estimated_send_bitrate_kbps_(1000, 1),
pacer_bitrate_kbps_(1000, 1),
target_bitrate_bps_(0),
pacer_bitrate_bps_(0),
last_bitrate_update_ms_(-1),
last_rtp_packet_received_ms_(-1),
first_packet_sent_ms_(-1),
estimated_send_bitrate_sum_kbits_(0),
pacer_bitrate_sum_kbits_(0),
num_bitrate_updates_(0),
congestion_controller_(
new CongestionController(module_process_thread_.get(),
call_stats_.get(),
@ -245,15 +243,15 @@ Call::~Call() {
}
void Call::UpdateSendHistograms() {
if (first_packet_sent_ms_ == -1)
if (num_bitrate_updates_ == 0 || first_packet_sent_ms_ == -1)
return;
int64_t elapsed_sec =
(clock_->TimeInMilliseconds() - first_packet_sent_ms_) / 1000;
if (elapsed_sec < metrics::kMinRunTimeInSeconds)
return;
rtc::CritScope lock(&bitrate_crit_);
int send_bitrate_kbps = estimated_send_bitrate_kbps_.ComputeTotalRate();
int pacer_bitrate_kbps = pacer_bitrate_kbps_.ComputeTotalRate();
int send_bitrate_kbps =
estimated_send_bitrate_sum_kbits_ / num_bitrate_updates_;
int pacer_bitrate_kbps = pacer_bitrate_sum_kbits_ / num_bitrate_updates_;
if (send_bitrate_kbps > 0) {
RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps",
send_bitrate_kbps);
@ -268,14 +266,12 @@ void Call::UpdateReceiveHistograms() {
if (first_rtp_packet_received_ms_ == -1)
return;
int64_t elapsed_sec =
(clock_->TimeInMilliseconds() - first_rtp_packet_received_ms_) / 1000;
(last_rtp_packet_received_ms_ - first_rtp_packet_received_ms_) / 1000;
if (elapsed_sec < metrics::kMinRunTimeInSeconds)
return;
int audio_bitrate_kbps =
received_audio_bytes_per_sec_.ComputeTotalRate() * 8 / 1000;
int video_bitrate_kbps =
received_video_bytes_per_sec_.ComputeTotalRate() * 8 / 1000;
int rtcp_bitrate_bps = received_rtcp_bytes_per_sec_.ComputeTotalRate() * 8;
int audio_bitrate_kbps = received_audio_bytes_ * 8 / elapsed_sec / 1000;
int video_bitrate_kbps = received_video_bytes_ * 8 / elapsed_sec / 1000;
int rtcp_bitrate_bps = received_rtcp_bytes_ * 8 / elapsed_sec;
if (video_bitrate_kbps > 0) {
RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.VideoBitrateReceivedInKbps",
video_bitrate_kbps);
@ -576,19 +572,6 @@ void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
int64_t rtt_ms) {
int64_t now_ms = clock_->TimeInMilliseconds();
int64_t time_since_last_update_ms = 0;
{
rtc::CritScope lock(&bitrate_crit_);
if (last_bitrate_update_ms_ >= 0)
time_since_last_update_ms = now_ms - last_bitrate_update_ms_;
estimated_send_bitrate_kbps_.AddSamples(
time_since_last_update_ms * (target_bitrate_bps_ / 1000) / 1000);
pacer_bitrate_kbps_.AddSamples(time_since_last_update_ms *
(pacer_bitrate_bps_ / 1000) / 1000);
target_bitrate_bps_ = target_bitrate_bps;
last_bitrate_update_ms_ = now_ms;
}
uint32_t allocated_bitrate_bps = bitrate_allocator_->OnNetworkChanged(
target_bitrate_bps, fraction_loss, rtt_ms);
@ -609,7 +592,11 @@ void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
std::max(target_bitrate_bps, allocated_bitrate_bps);
{
rtc::CritScope lock(&bitrate_crit_);
pacer_bitrate_bps_ = pacer_bitrate_bps;
// We only update these stats if we have send streams, and assume that
// OnNetworkChanged is called roughly with a fixed frequency.
estimated_send_bitrate_sum_kbits_ += target_bitrate_bps / 1000;
pacer_bitrate_sum_kbits_ += pacer_bitrate_bps / 1000;
++num_bitrate_updates_;
}
congestion_controller_->UpdatePacerBitrate(
target_bitrate_bps / 1000,
@ -672,7 +659,7 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
// Do NOT broadcast! Also make sure it's a valid packet.
// Return DELIVERY_UNKNOWN_SSRC if it can be determined that
// there's no receiver of the packet.
received_rtcp_bytes_per_sec_.AddSamples(length);
received_rtcp_bytes_ += length;
bool rtcp_delivered = false;
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
ReadLockScoped read_lock(*receive_crit_);
@ -705,15 +692,16 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
if (length < 12)
return DELIVERY_PACKET_ERROR;
last_rtp_packet_received_ms_ = clock_->TimeInMilliseconds();
if (first_rtp_packet_received_ms_ == -1)
first_rtp_packet_received_ms_ = clock_->TimeInMilliseconds();
first_rtp_packet_received_ms_ = last_rtp_packet_received_ms_;
uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
ReadLockScoped read_lock(*receive_crit_);
if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
auto it = audio_receive_ssrcs_.find(ssrc);
if (it != audio_receive_ssrcs_.end()) {
received_audio_bytes_per_sec_.AddSamples(length);
received_audio_bytes_ += length;
auto status = it->second->DeliverRtp(packet, length, packet_time)
? DELIVERY_OK
: DELIVERY_PACKET_ERROR;
@ -725,7 +713,7 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
auto it = video_receive_ssrcs_.find(ssrc);
if (it != video_receive_ssrcs_.end()) {
received_video_bytes_per_sec_.AddSamples(length);
received_video_bytes_ += length;
auto status = it->second->DeliverRtp(packet, length, packet_time)
? DELIVERY_OK
: DELIVERY_PACKET_ERROR;