src/base/synchronization/waitable_event_perftest.cc

// Copyright 2017 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/synchronization/waitable_event.h"

#include <numeric>

#include "base/threading/simple_thread.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/perf/perf_test.h"

namespace base {

namespace {

class TraceWaitableEvent {
 public:
  TraceWaitableEvent(size_t samples)
      : event_(WaitableEvent::ResetPolicy::AUTOMATIC,
               WaitableEvent::InitialState::NOT_SIGNALED),
        samples_(samples) {
    signal_times_.reserve(samples);
    wait_times_.reserve(samples);
  }

  ~TraceWaitableEvent() = default;

  void Signal() {
    TimeTicks start = TimeTicks::Now();
    event_.Signal();
    signal_times_.push_back(TimeTicks::Now() - start);
  }

  void Wait() {
    TimeTicks start = TimeTicks::Now();
    event_.Wait();
    wait_times_.push_back(TimeTicks::Now() - start);
  }

  bool TimedWaitUntil(const TimeTicks& end_time) {
    TimeTicks start = TimeTicks::Now();
    bool signaled = event_.TimedWaitUntil(end_time);
    wait_times_.push_back(TimeTicks::Now() - start);
    return signaled;
  }

  bool IsSignaled() { return event_.IsSignaled(); }

  const std::vector<TimeDelta>& signal_times() const { return signal_times_; }
  const std::vector<TimeDelta>& wait_times() const { return wait_times_; }
  size_t samples() const { return samples_; }

 private:
  WaitableEvent event_;

  std::vector<TimeDelta> signal_times_;
  std::vector<TimeDelta> wait_times_;

  const size_t samples_;

  DISALLOW_COPY_AND_ASSIGN(TraceWaitableEvent);
};

class SignalerThread : public SimpleThread {
 public:
  SignalerThread(TraceWaitableEvent* waiter, TraceWaitableEvent* signaler)
      : SimpleThread("WaitableEventPerfTest signaler"),
        waiter_(waiter),
        signaler_(signaler) {}

  ~SignalerThread() override = default;

  void Run() override {
    while (!stop_event_.IsSignaled()) {
      if (waiter_)
        waiter_->Wait();
      if (signaler_)
        signaler_->Signal();
    }
  }

  // Signals the thread to stop on the next iteration of its loop (which
  // will happen immediately if no |waiter_| is present or is signaled.
  void RequestStop() { stop_event_.Signal(); }

 private:
  WaitableEvent stop_event_{WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED};
  TraceWaitableEvent* waiter_;
  TraceWaitableEvent* signaler_;
  DISALLOW_COPY_AND_ASSIGN(SignalerThread);
};

void PrintPerfWaitableEvent(const TraceWaitableEvent* event,
                            const std::string& modifier,
                            const std::string& trace) {
  TimeDelta signal_time = std::accumulate(
      event->signal_times().begin(), event->signal_times().end(), TimeDelta());
  TimeDelta wait_time = std::accumulate(event->wait_times().begin(),
                                        event->wait_times().end(), TimeDelta());
  perf_test::PrintResult(
      "signal_time", modifier, trace,
      static_cast<size_t>(signal_time.InNanoseconds()) / event->samples(),
      "ns/sample", true);
  perf_test::PrintResult(
      "wait_time", modifier, trace,
      static_cast<size_t>(wait_time.InNanoseconds()) / event->samples(),
      "ns/sample", true);
}

}  // namespace

TEST(WaitableEventPerfTest, SingleThread) {
  const size_t kSamples = 1000;

  TraceWaitableEvent event(kSamples);

  for (size_t i = 0; i < kSamples; ++i) {
    event.Signal();
    event.Wait();
  }

  PrintPerfWaitableEvent(&event, "", "singlethread-1000-samples");
}

TEST(WaitableEventPerfTest, MultipleThreads) {
  const size_t kSamples = 1000;

  TraceWaitableEvent waiter(kSamples);
  TraceWaitableEvent signaler(kSamples);

  // The other thread will wait and signal on the respective opposite events.
  SignalerThread thread(&signaler, &waiter);
  thread.Start();

  for (size_t i = 0; i < kSamples; ++i) {
    signaler.Signal();
    waiter.Wait();
  }

  // Signal the stop event and then make sure the signaler event it is
  // waiting on is also signaled.
  thread.RequestStop();
  signaler.Signal();

  thread.Join();

  PrintPerfWaitableEvent(&waiter, "_waiter", "multithread-1000-samples");
  PrintPerfWaitableEvent(&signaler, "_signaler", "multithread-1000-samples");
}

TEST(WaitableEventPerfTest, Throughput) {
  // Reserve a lot of sample space.
  const size_t kCapacity = 500000;
  TraceWaitableEvent event(kCapacity);

  SignalerThread thread(nullptr, &event);
  thread.Start();

  TimeTicks end_time = TimeTicks::Now() + TimeDelta::FromSeconds(1);
  size_t count = 0;
  while (event.TimedWaitUntil(end_time)) {
    ++count;
  }

  thread.RequestStop();
  thread.Join();

  perf_test::PrintResult("counts", "", "throughput", count, "signals", true);
  PrintPerfWaitableEvent(&event, "", "throughput");

  // Make sure that allocation didn't happen during the test.
  EXPECT_LE(event.signal_times().capacity(), kCapacity);
  EXPECT_LE(event.wait_times().capacity(), kCapacity);
}

}  // namespace base