Internal QUICHE change PiperOrigin-RevId: 243880078 Change-Id: If9b4210b8e0ff73518b628d7460e94a765406f07
diff --git a/quic/quartc/test/bidi_test_runner.cc b/quic/quartc/test/bidi_test_runner.cc new file mode 100644 index 0000000..ebd6d33 --- /dev/null +++ b/quic/quartc/test/bidi_test_runner.cc
@@ -0,0 +1,170 @@ +// Copyright (c) 2019 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 "net/third_party/quiche/src/quic/quartc/test/bidi_test_runner.h" + +#include "net/third_party/quiche/src/quic/quartc/test/quartc_peer.h" + +namespace quic { +namespace test { + +namespace { + +bool ContainsSequenceNumbers(const std::vector<ReceivedMessage>& messages, + IdToSequenceNumberMap id_to_sequence_number) { + for (const auto& message : messages) { + auto it = id_to_sequence_number.find(message.frame.source_id); + if (it != id_to_sequence_number.end() && + it->second == message.frame.sequence_number) { + id_to_sequence_number.erase(it); + } + } + return id_to_sequence_number.empty(); +} + +void LogResults(const std::vector<ReceivedMessage>& messages) { + QuicTime::Delta max_delay = QuicTime::Delta::Zero(); + QuicTime::Delta total_delay = QuicTime::Delta::Zero(); + QuicByteCount total_throughput = 0; + for (const auto& message : messages) { + QuicTime::Delta one_way_delay = + message.receive_time - message.frame.send_time; + QUIC_VLOG(1) << "Frame details: source_id=" << message.frame.source_id + << ", sequence_number=" << message.frame.sequence_number + << ", one_way_delay (ms)=" << one_way_delay.ToMilliseconds(); + max_delay = std::max(max_delay, one_way_delay); + total_delay = total_delay + one_way_delay; + total_throughput += message.frame.size; + } + QuicBandwidth total_bandwidth = QuicBandwidth::FromBytesAndTimeDelta( + total_throughput, + messages.back().receive_time - messages.front().receive_time); + QUIC_LOG(INFO) << "Summary:\n max_delay (ms)=" << max_delay.ToMilliseconds() + << "\n average_delay (ms)=" + << total_delay.ToMilliseconds() / messages.size() + << "\n total_throughput (bytes)=" << total_throughput + << "\n total_bandwidth (bps)=" + << total_bandwidth.ToBitsPerSecond(); +} + +} // namespace + +BidiTestRunner::BidiTestRunner(simulator::Simulator* simulator, + QuartcPacketTransport* client_transport, + QuartcPacketTransport* server_transport) + : simulator_(simulator), + client_transport_(client_transport), + server_transport_(server_transport) { + // Set up default data source configs. + // Emulates an audio source with a 20 ms ptime. + QuartcDataSource::Config audio; + audio.id = 1; + audio.frame_interval = QuicTime::Delta::FromMilliseconds(20); + audio.min_bandwidth = QuicBandwidth::FromKBitsPerSecond(8); + audio.max_bandwidth = QuicBandwidth::FromKBitsPerSecond(64); + + // Emulates a video source at 30 fps. + QuartcDataSource::Config video; + video.id = 2; + video.frame_interval = QuicTime::Delta::FromMicroseconds(33333); + video.min_bandwidth = QuicBandwidth::FromKBitsPerSecond(25); + video.max_bandwidth = QuicBandwidth::FromKBitsPerSecond(5000); + + // Note: by placing audio first, it takes priority in bandwidth allocations. + client_configs_.push_back(audio); + client_configs_.push_back(video); + server_configs_.push_back(audio); + server_configs_.push_back(video); +} + +BidiTestRunner::~BidiTestRunner() { + // Note that peers must be deleted before endpoints. Peers close the + // connection when deleted. + client_peer_.reset(); + server_peer_.reset(); +} + +bool BidiTestRunner::RunTest(QuicTime::Delta test_duration) { + client_peer_ = QuicMakeUnique<QuartcPeer>( + simulator_->GetClock(), simulator_->GetAlarmFactory(), + simulator_->GetRandomGenerator(), client_configs_); + server_peer_ = QuicMakeUnique<QuartcPeer>( + simulator_->GetClock(), simulator_->GetAlarmFactory(), + simulator_->GetRandomGenerator(), server_configs_); + + QuartcEndpoint::Delegate* server_delegate = server_peer_.get(); + if (server_interceptor_) { + server_interceptor_->SetDelegate(server_delegate); + server_delegate = server_interceptor_; + } + server_endpoint_ = QuicMakeUnique<QuartcServerEndpoint>( + simulator_->GetAlarmFactory(), simulator_->GetClock(), server_delegate, + QuartcSessionConfig()); + + QuartcEndpoint::Delegate* client_delegate = client_peer_.get(); + if (client_interceptor_) { + client_interceptor_->SetDelegate(client_delegate); + client_delegate = client_interceptor_; + } + client_endpoint_ = QuicMakeUnique<QuartcClientEndpoint>( + simulator_->GetAlarmFactory(), simulator_->GetClock(), client_delegate, + QuartcSessionConfig(), server_endpoint_->server_crypto_config()); + + QuicTime start_time = simulator_->GetClock()->Now(); + server_endpoint_->Connect(server_transport_); + client_endpoint_->Connect(client_transport_); + + // Measure connect latency. + if (!simulator_->RunUntil([this] { return client_peer_->Enabled(); })) { + return false; + } + QuicTime client_connected = simulator_->GetClock()->Now(); + QuicTime::Delta client_connect_latency = client_connected - start_time; + + if (!simulator_->RunUntil([this] { return server_peer_->Enabled(); })) { + return false; + } + QuicTime server_connected = simulator_->GetClock()->Now(); + QuicTime::Delta server_connect_latency = server_connected - start_time; + + QUIC_LOG(INFO) << "Connect latencies (ms): client=" << client_connect_latency + << ", server=" << server_connect_latency; + + // Run the test. + simulator_->RunFor(test_duration); + + // Disable sending and drain. + // Note that draining by waiting for the last sequence number sent may be + // flaky if packet loss is enabled. However, simulator-based tests don't + // currently have any loss. + server_peer_->SetEnabled(false); + client_peer_->SetEnabled(false); + + IdToSequenceNumberMap sent_by_server = server_peer_->GetLastSequenceNumbers(); + if (!simulator_->RunUntil([this, &sent_by_server] { + return ContainsSequenceNumbers(client_peer_->received_messages(), + sent_by_server); + })) { + return false; + } + + IdToSequenceNumberMap sent_by_client = client_peer_->GetLastSequenceNumbers(); + if (!simulator_->RunUntil([this, &sent_by_client] { + return ContainsSequenceNumbers(server_peer_->received_messages(), + sent_by_client); + })) { + return false; + } + + // Compute results. + QUIC_LOG(INFO) << "Printing client->server results:"; + LogResults(server_peer_->received_messages()); + + QUIC_LOG(INFO) << "Printing server->client results:"; + LogResults(client_peer_->received_messages()); + return true; +} + +} // namespace test +} // namespace quic
diff --git a/quic/quartc/test/bidi_test_runner.h b/quic/quartc/test/bidi_test_runner.h new file mode 100644 index 0000000..b76695a --- /dev/null +++ b/quic/quartc/test/bidi_test_runner.h
@@ -0,0 +1,99 @@ +// Copyright (c) 2019 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 QUICHE_QUIC_QUARTC_TEST_BIDI_TEST_RUNNER_H_ +#define QUICHE_QUIC_QUARTC_TEST_BIDI_TEST_RUNNER_H_ + +#include "net/third_party/quiche/src/quic/core/quic_time.h" +#include "net/third_party/quiche/src/quic/quartc/quartc_endpoint.h" +#include "net/third_party/quiche/src/quic/quartc/quartc_packet_writer.h" +#include "net/third_party/quiche/src/quic/quartc/test/quartc_data_source.h" +#include "net/third_party/quiche/src/quic/quartc/test/quartc_peer.h" +#include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h" + +namespace quic { +namespace test { + +// Interface for a component that intercepts endpoint callbacks before +// forwarding them to another delegate. +class QuartcEndpointInterceptor : public QuartcEndpoint::Delegate { + public: + ~QuartcEndpointInterceptor() override = default; + + // Passes the test's endpoint delegate to this interceptor. The interceptor + // must forward all callbacks to this delegate as soon as it finishes handling + // them. + virtual void SetDelegate(QuartcEndpoint::Delegate* delegate) = 0; +}; + +// Runner for bidirectional media flow tests. +// +// BidiTestRunner allows an external fixture to set up transports, then executes +// a test. During the test, it sets up two QuartcPeers, connects them through +// the transports, and sends data in both directions for a specified duration. +// It then stops sending, waits for any pending messages to finish transmission, +// and then computes and logs a few basic metrics. +// +// For now, the runner computes the maximum and average one-way delay, the total +// throughput (in bytes) and the average bandwidth (in bits per second). It +// logs these to the test's text logs. +// +// By default, the BidiTestRunner emulates one video stream and one audio stream +// in each direction. The audio stream runs with a 20 ms ptime, between 8 and +// 64 kbps. The video stream runs at 30 fps, between 25 kbps and 5 mbps. +// Individual tests can overwrite the configs. +// +// BidiTestRunner provides a way for the test to register an "interceptor" on +// each endpoint. This allows a test to reconfigure that endpoint's session +// prior to beginning the test. For example, interceptors may be used to attach +// debug visitors or change the congestion controller. +class BidiTestRunner { + public: + // TODO(b/130540842): Make this compatible with non-simulator execution. + BidiTestRunner(simulator::Simulator* simulator, + QuartcPacketTransport* client_transport, + QuartcPacketTransport* server_transport); + + virtual ~BidiTestRunner(); + + void set_client_configs(std::vector<QuartcDataSource::Config> configs) { + client_configs_ = std::move(configs); + } + + void set_server_configs(std::vector<QuartcDataSource::Config> configs) { + server_configs_ = std::move(configs); + } + + void set_client_interceptor(QuartcEndpointInterceptor* interceptor) { + client_interceptor_ = interceptor; + } + + void set_server_interceptor(QuartcEndpointInterceptor* interceptor) { + server_interceptor_ = interceptor; + } + + virtual bool RunTest(QuicTime::Delta test_duration); + + private: + simulator::Simulator* simulator_; + QuartcPacketTransport* client_transport_; + QuartcPacketTransport* server_transport_; + + std::vector<QuartcDataSource::Config> client_configs_; + std::vector<QuartcDataSource::Config> server_configs_; + + QuartcEndpointInterceptor* client_interceptor_ = nullptr; + QuartcEndpointInterceptor* server_interceptor_ = nullptr; + + std::unique_ptr<QuartcServerEndpoint> server_endpoint_; + std::unique_ptr<QuartcClientEndpoint> client_endpoint_; + + std::unique_ptr<QuartcPeer> client_peer_; + std::unique_ptr<QuartcPeer> server_peer_; +}; + +} // namespace test +} // namespace quic + +#endif // QUICHE_QUIC_QUARTC_TEST_BIDI_TEST_RUNNER_H_
diff --git a/quic/quartc/test/quartc_bidi_test.cc b/quic/quartc/test/quartc_bidi_test.cc new file mode 100644 index 0000000..5c0e234 --- /dev/null +++ b/quic/quartc/test/quartc_bidi_test.cc
@@ -0,0 +1,57 @@ +// Copyright (c) 2019 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 "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "net/third_party/quiche/src/quic/core/quic_bandwidth.h" +#include "net/third_party/quiche/src/quic/core/quic_time.h" +#include "net/third_party/quiche/src/quic/core/quic_types.h" +#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h" +#include "net/third_party/quiche/src/quic/platform/api/quic_test.h" +#include "net/third_party/quiche/src/quic/quartc/simulated_packet_transport.h" +#include "net/third_party/quiche/src/quic/quartc/test/bidi_test_runner.h" +#include "net/third_party/quiche/src/quic/test_tools/simulator/link.h" +#include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h" + +namespace quic { +namespace test { +namespace { + +class QuartcBidiTest : public QuicTest { + protected: + QuartcBidiTest() {} + + void CreateTransports(QuicBandwidth bandwidth, + QuicTime::Delta propagation_delay, + QuicByteCount queue_length) { + client_transport_ = + QuicMakeUnique<simulator::SimulatedQuartcPacketTransport>( + &simulator_, "client_transport", "server_transport", queue_length); + server_transport_ = + QuicMakeUnique<simulator::SimulatedQuartcPacketTransport>( + &simulator_, "server_transport", "client_transport", queue_length); + client_server_link_ = QuicMakeUnique<simulator::SymmetricLink>( + client_transport_.get(), server_transport_.get(), bandwidth, + propagation_delay); + } + + simulator::Simulator simulator_; + + std::unique_ptr<simulator::SimulatedQuartcPacketTransport> client_transport_; + std::unique_ptr<simulator::SimulatedQuartcPacketTransport> server_transport_; + std::unique_ptr<simulator::SymmetricLink> client_server_link_; +}; + +TEST_F(QuartcBidiTest, Basic300kbps200ms) { + CreateTransports(QuicBandwidth::FromKBitsPerSecond(300), + QuicTime::Delta::FromMilliseconds(200), + 10 * kDefaultMaxPacketSize); + BidiTestRunner runner(&simulator_, client_transport_.get(), + server_transport_.get()); + EXPECT_TRUE(runner.RunTest(QuicTime::Delta::FromSeconds(30))); +} + +} // namespace +} // namespace test +} // namespace quic
diff --git a/quic/quartc/test/quartc_peer.cc b/quic/quartc/test/quartc_peer.cc index 32425c7..036ba03 100644 --- a/quic/quartc/test/quartc_peer.cc +++ b/quic/quartc/test/quartc_peer.cc
@@ -31,9 +31,9 @@ } } -std::map<int32_t, int64_t> QuartcPeer::GetLastSequenceNumbers() const { +IdToSequenceNumberMap QuartcPeer::GetLastSequenceNumbers() const { DCHECK_GE(configs_.size(), data_sources_.size()); - std::map<int32_t, int64_t> out; + IdToSequenceNumberMap out; for (int i = 0; i < data_sources_.size(); ++i) { out[configs_[i].id] = data_sources_[i]->sequence_number(); }
diff --git a/quic/quartc/test/quartc_peer.h b/quic/quartc/test/quartc_peer.h index 32b29be..68cb9ee 100644 --- a/quic/quartc/test/quartc_peer.h +++ b/quic/quartc/test/quartc_peer.h
@@ -23,6 +23,9 @@ namespace quic { namespace test { +// Map of source id to sequence number. +using IdToSequenceNumberMap = std::map<int32_t, int64_t>; + // ParsedQuartcDataFrame with a receive_time. struct ReceivedMessage { ParsedQuartcDataFrame frame; @@ -65,7 +68,7 @@ // Returns a map of source id to the sequence number of the last frame // produced by that source. - std::map<int32_t, int64_t> GetLastSequenceNumbers() const; + IdToSequenceNumberMap GetLastSequenceNumbers() const; // QuartcEndpoint::Delegate overrides. void OnSessionCreated(QuartcSession* session) override;