base: Test the cost of adding observers on message loops.

base/threading/thread_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 "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
@@ skipping 126 matching lines @@
 // This tries to test the 'best-case' as well as the 'worst-case' task posting
 // performance. The best-case keeps one thread alive such that it never yeilds,
 // while the worse-case forces a context switch for every task. Four threads are
 // used to ensure the threads do yeild (with just two it might be possible for
 // both threads to stay awake if they can signal each other fast enough).
 TEST_F(TaskPerfTest, TaskPingPong) {
   RunPingPongTest("1_Task_Threads", 1);
   RunPingPongTest("4_Task_Threads", 4);
 }
 
+
+// Same as above, but add observers to test their perf impact.
+class MessageLoopObserver : public base::MessageLoop::TaskObserver {
+ public:
+  virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  }
+  virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  }
+};
+MessageLoopObserver message_loop_observer;

[Nico, 2014/04/24 02:52:20]

Does this have to be a global? Can you make this a member of
TaskObserverPerfTest instead?

[epenner, 2014/04/24 03:14:36]

Good point. I wasn't thinking about it since it's a test. But best to have no
globals indeed. Moved it to the class.

+
+class TaskObserverPerfTest : public TaskPerfTest {
+ public:
+  virtual void Init() OVERRIDE {
+    TaskPerfTest::Init();
+    for (size_t i = 0; i < threads_.size(); i++) {
+      threads_[i]->message_loop()->AddTaskObserver(&message_loop_observer);
+    }
+  }
+};
+
+TEST_F(TaskObserverPerfTest, TaskPingPong) {
+  RunPingPongTest("1_Task_Threads_With_Observer", 1);
+  RunPingPongTest("4_Task_Threads_With_Observer", 4);
+}
+
 // Class to test our WaitableEvent performance by signaling back and fort.
 // WaitableEvent is templated so we can also compare with other versions.
 template <typename WaitableEventType>
 class EventPerfTest : public ThreadPerfTest {
  public:
   virtual void Init() OVERRIDE {
     for (size_t i = 0; i < threads_.size(); i++)
       events_.push_back(new WaitableEventType(false, false));
   }
 
@@ skipping 122 matching lines @@
 typedef EventPerfTest<PthreadEvent> PthreadEventPerfTest;
 TEST_F(PthreadEventPerfTest, EventPingPong) {
   RunPingPongTest("4_PthreadCondVar_Threads", 4);
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace base