Add ChannelProxy benchmark to ipc_perftests.

ipc/ipc_perftests.cc

 // Copyright (c) 2012 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 "build/build_config.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/perf_time_logger.h"
+#include "base/test/test_io_thread.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_sender.h"
 #include "ipc/ipc_test_base.h"
 
 namespace {
 
 // This test times the roundtrip IPC message cycle.
 //
 // TODO(brettw): Make this test run by default.
 
 class IPCChannelPerfTest : public IPCTestBase {
+ public:
+  virtual scoped_ptr<base::MessageLoop> CreateMessageLoop() OVERRIDE {
+    return make_scoped_ptr(new base::MessageLoop());

[viettrungluu, 2014/08/27 16:47:18]

nit: Same nit as below.

+  }
 };
 
 // This class simply collects stats about abstract "events" (each of which has a
 // start time and an end time).
 class EventTimeTracker {
  public:
   explicit EventTimeTracker(const char* name)
       : name_(name),
         count_(0) {
   }
@@ skipping 88 matching lines @@
     return true;
   }
 
  private:
   IPC::Channel* channel_;
   EventTimeTracker latency_tracker_;
 };
 
 class PerformanceChannelListener : public IPC::Listener {
  public:
-  PerformanceChannelListener()
-      : channel_(NULL),
+  explicit PerformanceChannelListener(const std::string& label)
+      : label_(label),
+        sender_(NULL),
         msg_count_(0),
         msg_size_(0),
         count_down_(0),
         latency_tracker_("Server messages") {
     VLOG(1) << "Server listener up";
   }
 
   virtual ~PerformanceChannelListener() {
     VLOG(1) << "Server listener down";
   }
 
-  void Init(IPC::Channel* channel) {
-    DCHECK(!channel_);
-    channel_ = channel;
+  void Init(IPC::Sender* sender) {
+    DCHECK(!sender_);
+    sender_ = sender;
   }
 
   // Call this before running the message loop.
   void SetTestParams(int msg_count, size_t msg_size) {
     DCHECK_EQ(0, count_down_);
     msg_count_ = msg_count;
     msg_size_ = msg_size;
     count_down_ = msg_count_;
     payload_ = std::string(msg_size_, 'a');
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
-    CHECK(channel_);
+    CHECK(sender_);
 
     PickleIterator iter(message);
     int64 time_internal;
     EXPECT_TRUE(iter.ReadInt64(&time_internal));
     int msgid;
     EXPECT_TRUE(iter.ReadInt(&msgid));
     std::string reflected_payload;
     EXPECT_TRUE(iter.ReadString(&reflected_payload));
 
     // Include message deserialization in latency.
     base::TimeTicks now = base::TimeTicks::Now();
 
     if (reflected_payload == "hello") {
       // Start timing on hello.
       latency_tracker_.Reset();
       DCHECK(!perf_logger_.get());
-      std::string test_name = base::StringPrintf(
-          "IPC_Perf_%dx_%u", msg_count_, static_cast<unsigned>(msg_size_));
+      std::string test_name =
+          base::StringPrintf("IPC_%s_Perf_%dx_%u",
+                             label_.c_str(),
+                             msg_count_,
+                             static_cast<unsigned>(msg_size_));
       perf_logger_.reset(new base::PerfTimeLogger(test_name.c_str()));
     } else {
       DCHECK_EQ(payload_.size(), reflected_payload.size());
 
       latency_tracker_.AddEvent(
           base::TimeTicks::FromInternalValue(time_internal), now);
 
       CHECK(count_down_ > 0);
       count_down_--;
       if (count_down_ == 0) {
         perf_logger_.reset();  // Stop the perf timer now.
         latency_tracker_.ShowResults();
         base::MessageLoop::current()->QuitWhenIdle();
         return true;
       }
     }
 
     IPC::Message* msg = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
     msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
     msg->WriteInt(count_down_);
     msg->WriteString(payload_);
-    channel_->Send(msg);
+    sender_->Send(msg);
     return true;
   }
 
  private:
-  IPC::Channel* channel_;
+  std::string label_;
+  IPC::Sender* sender_;
   int msg_count_;
   size_t msg_size_;
 
   int count_down_;
   std::string payload_;
   EventTimeTracker latency_tracker_;
   scoped_ptr<base::PerfTimeLogger> perf_logger_;
 };
 
-TEST_F(IPCChannelPerfTest, Performance) {
+TEST_F(IPCChannelPerfTest, ChannelPingPong) {
   Init("PerformanceClient");
 
   // Set up IPC channel and start client.
-  PerformanceChannelListener listener;
+  PerformanceChannelListener listener("Channel");
   CreateChannel(&listener);
   listener.Init(channel());
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   // Test several sizes. We use 12^N for message size, and limit the message
   // count to keep the test duration reasonable.
   const size_t kMsgSize[5] = {12, 144, 1728, 20736, 248832};
   const int kMessageCount[5] = {50000, 50000, 50000, 12000, 1000};
 
@@ skipping 29 matching lines @@
   ChannelReflectorListener listener;
   scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
       IPCTestBase::GetChannelName("PerformanceClient"), &listener));
   listener.Init(channel.get());
   CHECK(channel->Connect());
 
   base::MessageLoop::current()->Run();
   return 0;
 }
 
+TEST_F(IPCChannelPerfTest, ChannelProxyPingPong) {
+  Init("PerformanceClient");
+
+  base::TestIOThread io_thread((base::TestIOThread::kAutoStart));

[viettrungluu, 2014/08/27 16:47:18]

nit: I don't think there's any need for the extra parentheses (no vexing parse
here).

[Hajime Morrita, 2014/08/27 17:47:43]

Done.

+
+  // Set up IPC channel and start client.
+  PerformanceChannelListener listener("ChannelProxy");
+  CreateChannelProxy(&listener, io_thread.task_runner());
+  listener.Init(channel_proxy());
+  ASSERT_TRUE(StartClient());
+
+  // Test several sizes. We use 12^N for message size, and limit the message
+  // count to keep the test duration reasonable.
+  const size_t kMsgSize[5] = {12, 144, 1728, 20736, 248832};
+  const int kMessageCount[5] = {50000, 50000, 50000, 12000, 1000};
+
+  for (size_t i = 0; i < 5; i++) {
+    listener.SetTestParams(kMessageCount[i], kMsgSize[i]);
+
+    // This initial message will kick-start the ping-pong of messages.
+    IPC::Message* message =
+        new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
+    message->WriteInt(-1);
+    message->WriteString("hello");
+    sender()->Send(message);
+
+    // Run message loop.
+    base::MessageLoop::current()->Run();
+  }
+
+  // Send quit message.
+  IPC::Message* message = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+  message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
+  message->WriteInt(-1);
+  message->WriteString("quit");
+  sender()->Send(message);
+
+  EXPECT_TRUE(WaitForClientShutdown());
+  DestroyChannelProxy();
+}
+
 }  // namespace