blob: 084241db1e3d597f4b8188c23121fa67f6b699c1 [file] [log] [blame] [edit]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "quic/core/quic_write_blocked_list.h"
#include "quic/platform/api/quic_flag_utils.h"
#include "quic/platform/api/quic_flags.h"
namespace quic {
QuicWriteBlockedList::QuicWriteBlockedList(QuicTransportVersion version)
: priority_write_scheduler_(QuicVersionUsesCryptoFrames(version)
? std::numeric_limits<QuicStreamId>::max()
: 0),
last_priority_popped_(0) {
memset(batch_write_stream_id_, 0, sizeof(batch_write_stream_id_));
memset(bytes_left_for_batch_write_, 0, sizeof(bytes_left_for_batch_write_));
}
QuicWriteBlockedList::~QuicWriteBlockedList() {}
bool QuicWriteBlockedList::ShouldYield(QuicStreamId id) const {
for (const auto& stream : static_stream_collection_) {
if (stream.id == id) {
// Static streams should never yield to data streams, or to lower
// priority static stream.
return false;
}
if (stream.is_blocked) {
return true; // All data streams yield to static streams.
}
}
return priority_write_scheduler_.ShouldYield(id);
}
QuicStreamId QuicWriteBlockedList::PopFront() {
QuicStreamId static_stream_id;
if (static_stream_collection_.UnblockFirstBlocked(&static_stream_id)) {
return static_stream_id;
}
const auto id_and_precedence =
priority_write_scheduler_.PopNextReadyStreamAndPrecedence();
const QuicStreamId id = std::get<0>(id_and_precedence);
const spdy::SpdyPriority priority =
std::get<1>(id_and_precedence).spdy3_priority();
if (!priority_write_scheduler_.HasReadyStreams()) {
// If no streams are blocked, don't bother latching. This stream will be
// the first popped for its priority anyway.
batch_write_stream_id_[priority] = 0;
last_priority_popped_ = priority;
} else if (batch_write_stream_id_[priority] != id) {
// If newly latching this batch write stream, let it write 16k.
batch_write_stream_id_[priority] = id;
bytes_left_for_batch_write_[priority] = 16000;
last_priority_popped_ = priority;
}
return id;
}
void QuicWriteBlockedList::RegisterStream(
QuicStreamId stream_id,
bool is_static_stream,
const spdy::SpdyStreamPrecedence& precedence) {
QUICHE_DCHECK(!priority_write_scheduler_.StreamRegistered(stream_id))
<< "stream " << stream_id << " already registered";
QUICHE_DCHECK(precedence.is_spdy3_priority());
if (is_static_stream) {
static_stream_collection_.Register(stream_id);
return;
}
priority_write_scheduler_.RegisterStream(stream_id, precedence);
}
void QuicWriteBlockedList::UnregisterStream(QuicStreamId stream_id,
bool is_static) {
if (is_static) {
static_stream_collection_.Unregister(stream_id);
return;
}
priority_write_scheduler_.UnregisterStream(stream_id);
}
void QuicWriteBlockedList::UpdateStreamPriority(
QuicStreamId stream_id,
const spdy::SpdyStreamPrecedence& new_precedence) {
QUICHE_DCHECK(!static_stream_collection_.IsRegistered(stream_id));
QUICHE_DCHECK(new_precedence.is_spdy3_priority());
priority_write_scheduler_.UpdateStreamPrecedence(stream_id, new_precedence);
}
void QuicWriteBlockedList::UpdateBytesForStream(QuicStreamId stream_id,
size_t bytes) {
if (batch_write_stream_id_[last_priority_popped_] == stream_id) {
// If this was the last data stream popped by PopFront, update the
// bytes remaining in its batch write.
bytes_left_for_batch_write_[last_priority_popped_] -=
std::min(bytes_left_for_batch_write_[last_priority_popped_], bytes);
}
}
void QuicWriteBlockedList::AddStream(QuicStreamId stream_id) {
if (static_stream_collection_.SetBlocked(stream_id)) {
return;
}
bool push_front =
stream_id == batch_write_stream_id_[last_priority_popped_] &&
bytes_left_for_batch_write_[last_priority_popped_] > 0;
priority_write_scheduler_.MarkStreamReady(stream_id, push_front);
}
bool QuicWriteBlockedList::IsStreamBlocked(QuicStreamId stream_id) const {
for (const auto& stream : static_stream_collection_) {
if (stream.id == stream_id) {
return stream.is_blocked;
}
}
return priority_write_scheduler_.IsStreamReady(stream_id);
}
void QuicWriteBlockedList::StaticStreamCollection::Register(QuicStreamId id) {
QUICHE_DCHECK(!IsRegistered(id));
streams_.push_back({id, false});
}
bool QuicWriteBlockedList::StaticStreamCollection::IsRegistered(
QuicStreamId id) const {
for (const auto& stream : streams_) {
if (stream.id == id) {
return true;
}
}
return false;
}
void QuicWriteBlockedList::StaticStreamCollection::Unregister(QuicStreamId id) {
for (auto it = streams_.begin(); it != streams_.end(); ++it) {
if (it->id == id) {
if (it->is_blocked) {
--num_blocked_;
}
streams_.erase(it);
return;
}
}
QUICHE_DCHECK(false) << "Erasing a non-exist stream with id " << id;
}
bool QuicWriteBlockedList::StaticStreamCollection::SetBlocked(QuicStreamId id) {
for (auto& stream : streams_) {
if (stream.id == id) {
if (!stream.is_blocked) {
stream.is_blocked = true;
++num_blocked_;
}
return true;
}
}
return false;
}
bool QuicWriteBlockedList::StaticStreamCollection::UnblockFirstBlocked(
QuicStreamId* id) {
for (auto& stream : streams_) {
if (stream.is_blocked) {
--num_blocked_;
stream.is_blocked = false;
*id = stream.id;
return true;
}
}
return false;
}
} // namespace quic