OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 #include <utility> | 6 #include <utility> |
7 | 7 |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/message_loop/message_loop.h" | 9 #include "base/message_loop/message_loop.h" |
10 #include "base/run_loop.h" | 10 #include "base/run_loop.h" |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
132 "InProcessPingPong", "1000_Inactive", | 132 "InProcessPingPong", "1000_Inactive", |
133 kIterations / MojoTicksToSeconds(end_time - start_time), | 133 kIterations / MojoTicksToSeconds(end_time - start_time), |
134 "pings/second"); | 134 "pings/second"); |
135 | 135 |
136 delete[] inactive_services; | 136 delete[] inactive_services; |
137 } | 137 } |
138 } | 138 } |
139 | 139 |
140 class PingPongPaddle : public MessageReceiverWithResponderStatus { | 140 class PingPongPaddle : public MessageReceiverWithResponderStatus { |
141 public: | 141 public: |
142 PingPongPaddle(MessageReceiver* sender) : sender_(sender) {} | 142 PingPongPaddle(std::unique_ptr<MessageReceiver> sender) |
| 143 : sender_(std::move(sender)) {} |
143 | 144 |
144 void set_sender(MessageReceiver* sender) { sender_ = sender; } | 145 void set_sender(std::unique_ptr<MessageReceiver> sender) { |
| 146 sender_ = std::move(sender); |
| 147 } |
145 | 148 |
146 bool Accept(Message* message) override { | 149 bool Accept(Message* message) override { |
147 uint32_t count = message->header()->name; | 150 uint32_t count = message->header()->name; |
148 if (!quit_closure_.is_null()) { | 151 if (!quit_closure_.is_null()) { |
149 count++; | 152 count++; |
150 if (count >= expected_count_) { | 153 if (count >= expected_count_) { |
151 end_time_ = base::TimeTicks::Now(); | 154 end_time_ = base::TimeTicks::Now(); |
152 quit_closure_.Run(); | 155 quit_closure_.Run(); |
153 return true; | 156 return true; |
154 } | 157 } |
155 } | 158 } |
156 | 159 |
157 internal::MessageBuilder builder(count, 0, 8, 0); | 160 internal::MessageBuilder builder(count, 0, 8, 0); |
158 bool result = sender_->Accept(builder.message()); | 161 bool result = sender_->Accept(builder.message()); |
159 DCHECK(result); | 162 DCHECK(result); |
160 return true; | 163 return true; |
161 } | 164 } |
162 | 165 |
163 bool AcceptWithResponder(Message* message, | 166 bool AcceptWithResponder( |
164 MessageReceiverWithStatus* responder) override { | 167 Message* message, |
| 168 std::unique_ptr<MessageReceiverWithStatus> responder) override { |
165 NOTREACHED(); | 169 NOTREACHED(); |
166 return true; | 170 return true; |
167 } | 171 } |
168 | 172 |
169 base::TimeDelta Serve(uint32_t expected_count) { | 173 base::TimeDelta Serve(uint32_t expected_count) { |
170 base::RunLoop run_loop; | 174 base::RunLoop run_loop; |
171 | 175 |
172 expected_count_ = expected_count; | 176 expected_count_ = expected_count; |
173 quit_closure_ = run_loop.QuitClosure(); | 177 quit_closure_ = run_loop.QuitClosure(); |
174 | 178 |
175 start_time_ = base::TimeTicks::Now(); | 179 start_time_ = base::TimeTicks::Now(); |
176 internal::MessageBuilder builder(0, 0, 8, 0); | 180 internal::MessageBuilder builder(0, 0, 8, 0); |
177 bool result = sender_->Accept(builder.message()); | 181 bool result = sender_->Accept(builder.message()); |
178 DCHECK(result); | 182 DCHECK(result); |
179 | 183 |
180 run_loop.Run(); | 184 run_loop.Run(); |
181 | 185 |
182 return end_time_ - start_time_; | 186 return end_time_ - start_time_; |
183 } | 187 } |
184 | 188 |
185 private: | 189 private: |
186 base::TimeTicks start_time_; | 190 base::TimeTicks start_time_; |
187 base::TimeTicks end_time_; | 191 base::TimeTicks end_time_; |
188 uint32_t expected_count_ = 0; | 192 uint32_t expected_count_ = 0; |
189 MessageReceiver* sender_; | 193 std::unique_ptr<MessageReceiver> sender_; |
190 base::Closure quit_closure_; | 194 base::Closure quit_closure_; |
191 }; | 195 }; |
192 | 196 |
193 TEST_F(MojoBindingsPerftest, MultiplexRouterPingPong) { | 197 TEST_F(MojoBindingsPerftest, MultiplexRouterPingPong) { |
194 MessagePipe pipe; | 198 MessagePipe pipe; |
195 scoped_refptr<internal::MultiplexRouter> router0( | 199 scoped_refptr<internal::MultiplexRouter> router0( |
196 new internal::MultiplexRouter(std::move(pipe.handle0), | 200 new internal::MultiplexRouter(std::move(pipe.handle0), |
197 internal::MultiplexRouter::SINGLE_INTERFACE, | 201 internal::MultiplexRouter::SINGLE_INTERFACE, |
198 true, base::ThreadTaskRunnerHandle::Get())); | 202 true, base::ThreadTaskRunnerHandle::Get())); |
199 scoped_refptr<internal::MultiplexRouter> router1( | 203 scoped_refptr<internal::MultiplexRouter> router1( |
(...skipping 25 matching lines...) Expand all Loading... |
225 kTestIterations / duration.InSecondsF(), "pings/second"); | 229 kTestIterations / duration.InSecondsF(), "pings/second"); |
226 } | 230 } |
227 | 231 |
228 class CounterReceiver : public MessageReceiverWithResponderStatus { | 232 class CounterReceiver : public MessageReceiverWithResponderStatus { |
229 public: | 233 public: |
230 bool Accept(Message* message) override { | 234 bool Accept(Message* message) override { |
231 counter_++; | 235 counter_++; |
232 return true; | 236 return true; |
233 } | 237 } |
234 | 238 |
235 bool AcceptWithResponder(Message* message, | 239 bool AcceptWithResponder( |
236 MessageReceiverWithStatus* responder) override { | 240 Message* message, |
| 241 std::unique_ptr<MessageReceiverWithStatus> responder) override { |
237 NOTREACHED(); | 242 NOTREACHED(); |
238 return true; | 243 return true; |
239 } | 244 } |
240 | 245 |
241 uint32_t counter() const { return counter_; } | 246 uint32_t counter() const { return counter_; } |
242 | 247 |
243 void Reset() { counter_ = 0; } | 248 void Reset() { counter_ = 0; } |
244 | 249 |
245 private: | 250 private: |
246 uint32_t counter_ = 0; | 251 uint32_t counter_ = 0; |
(...skipping 28 matching lines...) Expand all Loading... |
275 if (i == 1) { | 280 if (i == 1) { |
276 test::LogPerfResult("MultiplexRouterDispatchCost", nullptr, | 281 test::LogPerfResult("MultiplexRouterDispatchCost", nullptr, |
277 kIterations[i] / duration.InSecondsF(), | 282 kIterations[i] / duration.InSecondsF(), |
278 "times/second"); | 283 "times/second"); |
279 } | 284 } |
280 } | 285 } |
281 } | 286 } |
282 | 287 |
283 } // namespace | 288 } // namespace |
284 } // namespace mojo | 289 } // namespace mojo |
OLD | NEW |