1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
// 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.
//
#ifndef NET_QUIC_QUIC_WRITE_BLOCKED_LIST_H_
#define NET_QUIC_QUIC_WRITE_BLOCKED_LIST_H_
#include <stddef.h>
#include <stdint.h>
#include <set>
#include "base/macros.h"
#include "net/base/net_export.h"
#include "net/quic/quic_flags.h"
#include "net/quic/quic_protocol.h"
#include "net/spdy/priority_write_scheduler.h"
namespace net {
// Keeps tracks of the QUIC streams that have data to write, sorted by
// priority. QUIC stream priority order is:
// Crypto stream > Headers stream > Data streams by requested priority.
class NET_EXPORT_PRIVATE QuicWriteBlockedList {
private:
typedef PriorityWriteScheduler<QuicStreamId> QuicPriorityWriteScheduler;
public:
QuicWriteBlockedList();
~QuicWriteBlockedList();
bool HasWriteBlockedDataStreams() const {
return priority_write_scheduler_.HasReadyStreams();
}
bool HasWriteBlockedCryptoOrHeadersStream() const {
return crypto_stream_blocked_ || headers_stream_blocked_;
}
size_t NumBlockedStreams() const {
size_t num_blocked = priority_write_scheduler_.NumReadyStreams();
if (crypto_stream_blocked_) {
++num_blocked;
}
if (headers_stream_blocked_) {
++num_blocked;
}
return num_blocked;
}
bool ShouldYield(QuicStreamId id) const {
if (id == kCryptoStreamId) {
return false; // The crypto stream yields to none.
}
if (crypto_stream_blocked_) {
return true; // If the crypto stream is blocked, all other streams yield.
}
if (id == kHeadersStreamId) {
return false; // The crypto stream isn't blocked so headers won't yield.
}
if (headers_stream_blocked_) {
return true; // All data streams yield to the headers stream.
}
return priority_write_scheduler_.ShouldYield(id);
}
// Pops the highest priorty stream, special casing crypto and headers streams.
// Latches the most recently popped data stream for batch writing purposes.
QuicStreamId PopFront() {
if (crypto_stream_blocked_) {
crypto_stream_blocked_ = false;
return kCryptoStreamId;
}
if (headers_stream_blocked_) {
headers_stream_blocked_ = false;
return kHeadersStreamId;
}
QuicStreamId id = priority_write_scheduler_.PopNextReadyStream();
SpdyPriority priority = priority_write_scheduler_.GetStreamPriority(id);
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 RegisterStream(QuicStreamId stream_id, SpdyPriority priority) {
priority_write_scheduler_.RegisterStream(stream_id, priority);
}
void UnregisterStream(QuicStreamId stream_id) {
priority_write_scheduler_.UnregisterStream(stream_id);
}
void UpdateStreamPriority(QuicStreamId stream_id, SpdyPriority new_priority) {
priority_write_scheduler_.UpdateStreamPriority(stream_id, new_priority);
}
void 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_] -=
static_cast<int32_t>(bytes);
}
}
// Pushes a stream to the back of the list for its priority level *unless*
// it is latched for doing batched writes in which case it goes to the front
// of the list for its priority level.
// Headers and crypto streams are special cased to always resume first.
void AddStream(QuicStreamId stream_id) {
if (stream_id == kCryptoStreamId) {
// TODO(avd) Add DCHECK(!crypto_stream_blocked_)
crypto_stream_blocked_ = true;
return;
}
if (stream_id == kHeadersStreamId) {
// TODO(avd) Add DCHECK(!headers_stream_blocked_);
headers_stream_blocked_ = true;
return;
}
bool push_front =
FLAGS_quic_batch_writes &&
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);
return;
}
bool crypto_stream_blocked() const { return crypto_stream_blocked_; }
bool headers_stream_blocked() const { return headers_stream_blocked_; }
private:
QuicPriorityWriteScheduler priority_write_scheduler_;
// If performing batch writes, this will be the stream ID of the stream doing
// batch writes for this priority level. We will allow this stream to write
// until it has written kBatchWriteSize bytes, it has no more data to write,
// or a higher priority stream preempts.
QuicStreamId batch_write_stream_id_[kV3LowestPriority + 1];
// Set to kBatchWriteSize when we set a new batch_write_stream_id_ for a given
// priority. This is decremented with each write the stream does until it is
// done with its batch write.
int32_t bytes_left_for_batch_write_[kV3LowestPriority + 1];
// Tracks the last priority popped for UpdateBytesForStream.
SpdyPriority last_priority_popped_;
bool crypto_stream_blocked_;
bool headers_stream_blocked_;
DISALLOW_COPY_AND_ASSIGN(QuicWriteBlockedList);
};
} // namespace net
#endif // NET_QUIC_QUIC_WRITE_BLOCKED_LIST_H_
|
