OLD | NEW |
| (Empty) |
1 // Copyright (c) 2017 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef NET_SPDY_LIFO_WRITE_SCHEDULER_H_ | |
6 #define NET_SPDY_LIFO_WRITE_SCHEDULER_H_ | |
7 | |
8 #include <map> | |
9 #include <set> | |
10 #include <tuple> | |
11 #include <vector> | |
12 | |
13 #include "net/spdy/platform/api/spdy_string_utils.h" | |
14 #include "net/spdy/write_scheduler.h" | |
15 | |
16 namespace net { | |
17 | |
18 namespace test { | |
19 | |
20 template <typename StreamIdType> | |
21 class LifoWriteSchedulerPeer; | |
22 | |
23 } // namespace test | |
24 | |
25 // Create a write scheduler where the stream added last will have the highest | |
26 // priority. | |
27 template <typename StreamIdType> | |
28 class LifoWriteScheduler : public WriteScheduler<StreamIdType> { | |
29 public: | |
30 using typename WriteScheduler<StreamIdType>::StreamPrecedenceType; | |
31 | |
32 LifoWriteScheduler() = default; | |
33 | |
34 void RegisterStream(StreamIdType stream_id, | |
35 const StreamPrecedenceType& /*precedence*/) override; | |
36 | |
37 void UnregisterStream(StreamIdType stream_id) override; | |
38 | |
39 bool StreamRegistered(StreamIdType stream_id) const override { | |
40 return registered_streams_.find(stream_id) != registered_streams_.end(); | |
41 } | |
42 | |
43 // Stream precedence is not supported by this scheduler. | |
44 StreamPrecedenceType GetStreamPrecedence( | |
45 StreamIdType stream_id) const override { | |
46 return StreamPrecedenceType(kV3LowestPriority); | |
47 } | |
48 | |
49 void UpdateStreamPrecedence(StreamIdType stream_id, | |
50 const StreamPrecedenceType& precedence) override { | |
51 } | |
52 | |
53 std::vector<StreamIdType> GetStreamChildren( | |
54 StreamIdType stream_id) const override { | |
55 return std::vector<StreamIdType>(); | |
56 } | |
57 | |
58 void RecordStreamEventTime(StreamIdType stream_id, | |
59 int64_t now_in_usec) override; | |
60 | |
61 int64_t GetLatestEventWithPrecedence(StreamIdType stream_id) const override; | |
62 | |
63 StreamIdType PopNextReadyStream() override; | |
64 | |
65 std::tuple<StreamIdType, StreamPrecedenceType> | |
66 PopNextReadyStreamAndPrecedence() override { | |
67 return std::make_tuple(PopNextReadyStream(), | |
68 StreamPrecedenceType(kV3LowestPriority)); | |
69 } | |
70 | |
71 bool ShouldYield(StreamIdType stream_id) const override { | |
72 // stream_id is not necessary to be on the ready list. | |
73 return stream_id < *ready_streams_.rbegin(); | |
74 } | |
75 | |
76 void MarkStreamReady(StreamIdType stream_id, bool /*add_to_front*/) override; | |
77 | |
78 void MarkStreamNotReady(StreamIdType stream_id) override; | |
79 | |
80 bool HasReadyStreams() const override { return !ready_streams_.empty(); } | |
81 size_t NumReadyStreams() const override { return ready_streams_.size(); } | |
82 | |
83 private: | |
84 friend class test::LifoWriteSchedulerPeer<StreamIdType>; | |
85 | |
86 std::set<StreamIdType> ready_streams_; | |
87 std::map<StreamIdType, int64_t> registered_streams_; | |
88 }; | |
89 | |
90 template <typename StreamIdType> | |
91 void LifoWriteScheduler<StreamIdType>::RegisterStream( | |
92 StreamIdType stream_id, | |
93 const StreamPrecedenceType& /*precedence*/) { | |
94 if (StreamRegistered(stream_id)) { | |
95 SPDY_BUG << "Stream " << stream_id << " already registered"; | |
96 return; | |
97 } | |
98 registered_streams_.emplace_hint(registered_streams_.end(), stream_id, 0); | |
99 } | |
100 | |
101 template <typename StreamIdType> | |
102 void LifoWriteScheduler<StreamIdType>::UnregisterStream( | |
103 StreamIdType stream_id) { | |
104 if (!StreamRegistered(stream_id)) { | |
105 SPDY_BUG << "Stream " << stream_id << " is not registered"; | |
106 return; | |
107 } | |
108 registered_streams_.erase(stream_id); | |
109 } | |
110 | |
111 template <typename StreamIdType> | |
112 void LifoWriteScheduler<StreamIdType>::RecordStreamEventTime( | |
113 StreamIdType stream_id, | |
114 int64_t now_in_usec) { | |
115 auto it = registered_streams_.find(stream_id); | |
116 if (it != registered_streams_.end()) { | |
117 it->second = now_in_usec; | |
118 } else { | |
119 SPDY_BUG << "Stream " << stream_id << " is not registered"; | |
120 } | |
121 } | |
122 | |
123 template <typename StreamIdType> | |
124 int64_t LifoWriteScheduler<StreamIdType>::GetLatestEventWithPrecedence( | |
125 StreamIdType stream_id) const { | |
126 if (!StreamRegistered(stream_id)) { | |
127 SPDY_BUG << "Stream " << stream_id << " is not registered"; | |
128 return 0; | |
129 } | |
130 int64_t latest_event_time_us = 0; | |
131 for (auto it = registered_streams_.rbegin(); it != registered_streams_.rend(); | |
132 ++it) { | |
133 if (stream_id < it->first) { | |
134 if (it->second > latest_event_time_us) { | |
135 latest_event_time_us = it->second; | |
136 } | |
137 } else { | |
138 break; | |
139 } | |
140 } | |
141 return latest_event_time_us; | |
142 } | |
143 | |
144 template <typename StreamIdType> | |
145 StreamIdType LifoWriteScheduler<StreamIdType>::PopNextReadyStream() { | |
146 if (ready_streams_.empty()) { | |
147 SPDY_BUG << "No ready streams available"; | |
148 return 0; | |
149 } | |
150 auto it = --ready_streams_.end(); | |
151 StreamIdType id = *it; | |
152 ready_streams_.erase(it); | |
153 return id; | |
154 } | |
155 | |
156 template <typename StreamIdType> | |
157 void LifoWriteScheduler<StreamIdType>::MarkStreamReady(StreamIdType stream_id, | |
158 bool /*add_to_front*/) { | |
159 if (!StreamRegistered(stream_id)) { | |
160 SPDY_BUG << "Stream " << stream_id << " is not registered"; | |
161 return; | |
162 } | |
163 if (ready_streams_.find(stream_id) != ready_streams_.end()) { | |
164 SPDY_BUG << "Stream already exists in the list"; | |
165 return; | |
166 } | |
167 ready_streams_.insert(stream_id); | |
168 } | |
169 | |
170 template <typename StreamIdType> | |
171 void LifoWriteScheduler<StreamIdType>::MarkStreamNotReady( | |
172 StreamIdType stream_id) { | |
173 auto it = ready_streams_.find(stream_id); | |
174 if (it == ready_streams_.end()) { | |
175 SPDY_BUG << "Try to remove a stream that is not on list"; | |
176 return; | |
177 } | |
178 ready_streams_.erase(it); | |
179 } | |
180 | |
181 } // namespace net | |
182 | |
183 #endif // NET_SPDY_LIFO_WRITE_SCHEDULER_H_ | |
OLD | NEW |