Update remoting_perftest to evaluate bandwidth estimation.

remoting/test/protocol_perftest.cc

 // 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 <numeric>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
@@ skipping 42 matching lines @@
 
 namespace {
 
 const char kHostJid[] = "host_jid@example.com/host";
 const char kHostOwner[] = "jane.doe@example.com";
 const char kClientJid[] = "jane.doe@example.com/client";
 const char kHostId[] = "ABC123";
 const char kHostPin[] = "123456";
 
 struct NetworkPerformanceParams {
-  NetworkPerformanceParams(int bandwidth,
-                           int max_buffers,
+  // |buffer_s| defines buffer size in seconds. actual buffer size is calculated
+  // based on bandwidth_kbps
+  NetworkPerformanceParams(int bandwidth_kbps,
+                           double buffer_s,
                            double latency_average_ms,
                            double latency_stddev_ms,
-                           double out_of_order_rate)
-      : bandwidth(bandwidth),
-        max_buffers(max_buffers),
+                           double out_of_order_rate,
+                           double signaling_latency_ms)
+      : bandwidth_kbps(bandwidth_kbps),
+        max_buffers(buffer_s * bandwidth_kbps * 1000 / 8),
         latency_average(base::TimeDelta::FromMillisecondsD(latency_average_ms)),
         latency_stddev(base::TimeDelta::FromMillisecondsD(latency_stddev_ms)),
-        out_of_order_rate(out_of_order_rate) {}
+        out_of_order_rate(out_of_order_rate),
+        signaling_latency(
+            base::TimeDelta::FromMillisecondsD(signaling_latency_ms)) {}
 
-  int bandwidth;
+  int bandwidth_kbps;
   int max_buffers;
   base::TimeDelta latency_average;
   base::TimeDelta latency_stddev;
   double out_of_order_rate;
+  base::TimeDelta signaling_latency;
 };
 
 class FakeCursorShapeStub : public protocol::CursorShapeStub {
  public:
   FakeCursorShapeStub() {}
   ~FakeCursorShapeStub() override {}
 
   // protocol::CursorShapeStub interface.
   void SetCursorShape(const protocol::CursorShapeInfo& cursor_shape) override{};
 };
@@ skipping 160 matching lines @@
         FROM_HERE,
         base::Bind(&ProtocolPerfTest::StartHost, base::Unretained(this)));
   }
 
   void StartHost() {
     DCHECK(host_thread_.task_runner()->BelongsToCurrentThread());
 
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
     host_signaling_.reset(new FakeSignalStrategy(kHostJid));
+    host_signaling_->set_send_delay(GetParam().signaling_latency);
     host_signaling_->ConnectTo(client_signaling_.get());
 
     protocol::NetworkSettings network_settings(
         protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
     std::unique_ptr<FakePortAllocatorFactory> port_allocator_factory(
         new FakePortAllocatorFactory(fake_network_dispatcher_));
     port_allocator_factory->socket_factory()->SetBandwidth(
-        GetParam().bandwidth, GetParam().max_buffers);
+        GetParam().bandwidth_kbps * 1000 / 8, GetParam().max_buffers);
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
             host_signaling_.get(), std::move(port_allocator_factory), nullptr,
             network_settings, protocol::TransportRole::SERVER));
     std::unique_ptr<protocol::SessionManager> session_manager(
         new protocol::JingleSessionManager(host_signaling_.get()));
@@ skipping 29 matching lines @@
 
     host_->AddStatusObserver(this);
     host_->Start(kHostOwner);
 
     message_loop_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&ProtocolPerfTest::StartClientAfterHost,
                               base::Unretained(this)));
   }
 
   void StartClientAfterHost() {
+    client_signaling_->set_send_delay(GetParam().signaling_latency);
     client_signaling_->ConnectTo(host_signaling_.get());
 
     protocol::NetworkSettings network_settings(
         protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
     // Initialize client.
     client_context_.reset(
         new ClientContext(base::ThreadTaskRunnerHandle::Get()));
     client_context_->Start();
 
     std::unique_ptr<FakePortAllocatorFactory> port_allocator_factory(
         new FakePortAllocatorFactory(fake_network_dispatcher_));
     client_socket_factory_ = port_allocator_factory->socket_factory();
     port_allocator_factory->socket_factory()->SetBandwidth(
-        GetParam().bandwidth, GetParam().max_buffers);
+        GetParam().bandwidth_kbps * 1000 / 8, GetParam().max_buffers);
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
             host_signaling_.get(), std::move(port_allocator_factory), nullptr,
             network_settings, protocol::TransportRole::CLIENT));
 
     protocol::ClientAuthenticationConfig client_auth_config;
@@ skipping 61 matching lines @@
   std::unique_ptr<webrtc::DesktopFrame> last_video_frame_;
   std::vector<protocol::FrameStats> frame_stats_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProtocolPerfTest);
 };
 
 INSTANTIATE_TEST_CASE_P(
     NoDelay,
     ProtocolPerfTest,
-    ::testing::Values(NetworkPerformanceParams(0, 0, 0, 0, 0.0)));
+    ::testing::Values(NetworkPerformanceParams(0, 0, 0, 0, 0.0, 0)));
 
 INSTANTIATE_TEST_CASE_P(
     HighLatency,
     ProtocolPerfTest,
-    ::testing::Values(NetworkPerformanceParams(0, 0, 300, 30, 0.0),
-                      NetworkPerformanceParams(0, 0, 30, 10, 0.0)));
+    ::testing::Values(NetworkPerformanceParams(0, 0, 300, 30, 0.0, 0),
+                      NetworkPerformanceParams(0, 0, 30, 10, 0.0, 0)));
 
 INSTANTIATE_TEST_CASE_P(
     OutOfOrder,
     ProtocolPerfTest,
-    ::testing::Values(NetworkPerformanceParams(0, 0, 2, 0, 0.01),
-                      NetworkPerformanceParams(0, 0, 30, 1, 0.01),
-                      NetworkPerformanceParams(0, 0, 30, 1, 0.1),
-                      NetworkPerformanceParams(0, 0, 300, 20, 0.01),
-                      NetworkPerformanceParams(0, 0, 300, 20, 0.1)));
+    ::testing::Values(NetworkPerformanceParams(0, 0, 2, 0, 0.01, 0),
+                      NetworkPerformanceParams(0, 0, 30, 1, 0.01, 0),
+                      NetworkPerformanceParams(0, 0, 30, 1, 0.1, 0),
+                      NetworkPerformanceParams(0, 0, 300, 20, 0.01, 0),
+                      NetworkPerformanceParams(0, 0, 300, 20, 0.1, 0)));
 
 INSTANTIATE_TEST_CASE_P(
     LimitedBandwidth,
     ProtocolPerfTest,
     ::testing::Values(
         // 100 Mbps
-        NetworkPerformanceParams(12500000, 12500000, 2, 1, 0.0),
+        NetworkPerformanceParams(100000, 0.25, 2, 1, 0.0, 0),
+        NetworkPerformanceParams(100000, 1.0, 2, 1, 0.0, 0),
         // 8 Mbps
-        NetworkPerformanceParams(1000000, 300000, 30, 5, 0.01),
-        NetworkPerformanceParams(1000000, 2000000, 30, 5, 0.01),
+        NetworkPerformanceParams(8000, 0.25, 30, 5, 0.01, 0),
+        NetworkPerformanceParams(8000, 1.0, 30, 5, 0.01, 0),
         // 2 Mbps
-        NetworkPerformanceParams(250000, 300000, 30, 5, 0.01),
-        NetworkPerformanceParams(250000, 2000000, 30, 5, 0.01),
-        // 800 kBps
-        NetworkPerformanceParams(100000, 30000, 130, 5, 0.00),
-        NetworkPerformanceParams(100000, 200000, 130, 5, 0.00)));
+        NetworkPerformanceParams(2000, 0.25, 30, 5, 0.01, 0),
+        NetworkPerformanceParams(2000, 1.0, 30, 5, 0.01, 0),
+        // 800 kbps
+        NetworkPerformanceParams(800, 0.25, 130, 5, 0.00, 0),
+        NetworkPerformanceParams(800, 1.0, 130, 5, 0.00, 0)));
+
+INSTANTIATE_TEST_CASE_P(
+    SlowSignaling,
+    ProtocolPerfTest,
+    ::testing::Values(NetworkPerformanceParams(8000, 0.25, 30, 0, 0.0, 50),
+                      NetworkPerformanceParams(8000, 0.25, 30, 0, 0.0, 500)));
 
 // TotalLatency[Ice|Webrtc] tests measure video latency in the case when the
 // whole screen is updated occasionally. It's intended to simulate the case when
 // user actions (e.g. Alt-Tab, click on the task bar) cause whole screen to be
 // updated.
 void ProtocolPerfTest::MeasureTotalLatency(bool use_webrtc) {
   scoped_refptr<test::CyclicFrameGenerator> frame_generator =
       test::CyclicFrameGenerator::Create();
   desktop_environment_factory_->set_frame_generator(
       base::Bind(&test::CyclicFrameGenerator::GenerateFrame, frame_generator));
@@ skipping 50 matching lines @@
           ++big_update_count;
           break;
         case test::CyclicFrameGenerator::ChangeType::CURSOR:
           total_latency_small_updates += latency;
           ++small_update_count;
           break;
       }
     }
   }
 
+  WaitFrameStats(total_frames);
+
   CHECK(big_update_count);
   VLOG(0) << "Average latency for big updates: "
           << (total_latency_big_updates / big_update_count).InMillisecondsF();
 
   if (small_update_count) {
     VLOG(0)
         << "Average latency for small updates: "
         << (total_latency_small_updates / small_update_count).InMillisecondsF();
   }
+
+  double average_bwe =
+      std::accumulate(frame_stats_.begin() + warm_up_frames,
+                      frame_stats_.begin() + total_frames, 0.0,
+                      [](double sum, const protocol::FrameStats& stats) {
+                        return sum + stats.host_stats.bandwidth_estimate_kbps;
+                      }) /
+      (total_frames - warm_up_frames);
+  VLOG(0) << "Average BW estimate: " << average_bwe
+          << " (actual: " << GetParam().bandwidth_kbps << ")";
 }
 
 TEST_P(ProtocolPerfTest, TotalLatencyIce) {
   MeasureTotalLatency(false);
 }
 
 TEST_P(ProtocolPerfTest, TotalLatencyWebrtc) {
   MeasureTotalLatency(true);
 }
 
@@ skipping 39 matching lines @@
                       });
 
   base::TimeDelta latency_sum = std::accumulate(
       frame_stats_.begin() + warm_up_frames,
       frame_stats_.begin() + warm_up_frames + num_frames, base::TimeDelta(),
       [](base::TimeDelta sum, const protocol::FrameStats& stats) {
         return sum + (stats.client_stats.time_rendered -
                       stats.host_stats.latest_event_timestamp);
       });
 
+  double average_bwe =
+      std::accumulate(frame_stats_.begin() + warm_up_frames,
+                      frame_stats_.begin() + warm_up_frames + num_frames, 0.0,
+                      [](double sum, const protocol::FrameStats& stats) {
+                        return sum + stats.host_stats.bandwidth_estimate_kbps;
+                      }) /
+      num_frames;
+
   VLOG(0) << "FPS: " << num_frames / total_time.InSecondsF();
   VLOG(0) << "Average latency: " << latency_sum.InMillisecondsF() / num_frames
           << " ms";
   VLOG(0) << "Total size: " << total_size << " bytes";
   VLOG(0) << "Bandwidth utilization: "
-          << 100 * total_size / (total_time.InSecondsF() * GetParam().bandwidth)
+          << 100 * total_size / (total_time.InSecondsF() *
+                                 GetParam().bandwidth_kbps * 1000 / 8)
           << "%";
   VLOG(0) << "Network buffer delay (bufferbloat), average: "
           << client_socket_factory_->average_buffer_delay().InMilliseconds()
           << " ms,  max:"
           << client_socket_factory_->max_buffer_delay().InMilliseconds()
           << " ms";
   VLOG(0) << "Packet drop rate: " << client_socket_factory_->drop_rate();
+  VLOG(0) << "Average BW estimate: " << average_bwe
+          << " (actual: " << GetParam().bandwidth_kbps << ")";
 }
 
 TEST_P(ProtocolPerfTest, ScrollPerformanceIce) {
   MeasureScrollPerformance(false);
 }
 
 TEST_P(ProtocolPerfTest, ScrollPerformanceWebrtc) {
   MeasureScrollPerformance(true);
 }
 
 }  // namespace remoting