mojo/public/c/system/tests/core_perftest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This tests the performance of the C API.
   6
   7 #include "mojo/public/c/system/core.h"
   8
   9 #include <assert.h>
  10 #include <stddef.h>
  11 #include <stdint.h>
  12 #include <stdio.h>
  13
  14 #include "mojo/public/cpp/system/macros.h"
  15 #include "mojo/public/cpp/test_support/test_support.h"
  16 #include "mojo/public/cpp/test_support/test_utils.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 // TODO(vtl): (here and below) crbug.com/342893
  20 #if !defined(WIN32)
  21 #include <time.h>
  22 #include "mojo/public/cpp/utility/thread.h"
  23 #endif  // !defined(WIN32)
  24
  25 namespace {
  26
  27 #if !defined(WIN32)
  28 class MessagePipeWriterThread : public mojo::Thread {
  29  public:
  30   MessagePipeWriterThread(MojoHandle handle, uint32_t num_bytes)
  31       : handle_(handle), num_bytes_(num_bytes), num_writes_(0) {}
  32   ~MessagePipeWriterThread() override {}
  33
  34   void Run() override {
  35     char buffer[10000];
  36     assert(num_bytes_ <= sizeof(buffer));
  37
  38     // TODO(vtl): Should I throttle somehow?
  39     for (;;) {
  40       MojoResult result = MojoWriteMessage(
  41           handle_, buffer, num_bytes_, NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
  42       if (result == MOJO_RESULT_OK) {
  43         num_writes_++;
  44         continue;
  45       }
  46
  47       // We failed to write.
  48       // Either |handle_| or its peer was closed.
  49       assert(result == MOJO_RESULT_INVALID_ARGUMENT ||
  50              result == MOJO_RESULT_FAILED_PRECONDITION);
  51       break;
  52     }
  53   }
  54
  55   // Use only after joining the thread.
  56   int64_t num_writes() const { return num_writes_; }
  57
  58  private:
  59   const MojoHandle handle_;
  60   const uint32_t num_bytes_;
  61   int64_t num_writes_;
  62
  63   MOJO_DISALLOW_COPY_AND_ASSIGN(MessagePipeWriterThread);
  64 };
  65
  66 class MessagePipeReaderThread : public mojo::Thread {
  67  public:
  68   explicit MessagePipeReaderThread(MojoHandle handle)
  69       : handle_(handle), num_reads_(0) {}
  70   ~MessagePipeReaderThread() override {}
  71
  72   void Run() override {
  73     char buffer[10000];
  74
  75     for (;;) {
  76       uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
  77       MojoResult result = MojoReadMessage(
  78           handle_, buffer, &num_bytes, NULL, NULL, MOJO_READ_MESSAGE_FLAG_NONE);
  79       if (result == MOJO_RESULT_OK) {
  80         num_reads_++;
  81         continue;
  82       }
  83
  84       if (result == MOJO_RESULT_SHOULD_WAIT) {
  85         result = MojoWait(
  86             handle_, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
  87         if (result == MOJO_RESULT_OK) {
  88           // Go to the top of the loop to read again.
  89           continue;
  90         }
  91       }
  92
  93       // We failed to read and possibly failed to wait.
  94       // Either |handle_| or its peer was closed.
  95       assert(result == MOJO_RESULT_INVALID_ARGUMENT ||
  96              result == MOJO_RESULT_FAILED_PRECONDITION);
  97       break;
  98     }
  99   }
 100
 101   // Use only after joining the thread.
 102   int64_t num_reads() const { return num_reads_; }
 103
 104  private:
 105   const MojoHandle handle_;
 106   int64_t num_reads_;
 107
 108   MOJO_DISALLOW_COPY_AND_ASSIGN(MessagePipeReaderThread);
 109 };
 110 #endif  // !defined(WIN32)
 111
 112 class CorePerftest : public testing::Test {
 113  public:
 114   CorePerftest() : buffer_(NULL), num_bytes_(0) {}
 115   virtual ~CorePerftest() {}
 116
 117   static void NoOp(void* /*closure*/) {}
 118
 119   static void MessagePipe_CreateAndClose(void* closure) {
 120     CorePerftest* self = static_cast<CorePerftest*>(closure);
 121     MojoResult result = MojoCreateMessagePipe(NULL, &self->h0_, &self->h1_);
 122     MOJO_ALLOW_UNUSED_LOCAL(result);
 123     assert(result == MOJO_RESULT_OK);
 124     result = MojoClose(self->h0_);
 125     assert(result == MOJO_RESULT_OK);
 126     result = MojoClose(self->h1_);
 127     assert(result == MOJO_RESULT_OK);
 128   }
 129
 130   static void MessagePipe_WriteAndRead(void* closure) {
 131     CorePerftest* self = static_cast<CorePerftest*>(closure);
 132     MojoResult result = MojoWriteMessage(self->h0_, self->buffer_,
 133                                          self->num_bytes_, NULL, 0,
 134                                          MOJO_WRITE_MESSAGE_FLAG_NONE);
 135     MOJO_ALLOW_UNUSED_LOCAL(result);
 136     assert(result == MOJO_RESULT_OK);
 137     uint32_t read_bytes = self->num_bytes_;
 138     result = MojoReadMessage(self->h1_, self->buffer_, &read_bytes, NULL, NULL,
 139                              MOJO_READ_MESSAGE_FLAG_NONE);
 140     assert(result == MOJO_RESULT_OK);
 141   }
 142
 143   static void MessagePipe_EmptyRead(void* closure) {
 144     CorePerftest* self = static_cast<CorePerftest*>(closure);
 145     MojoResult result = MojoReadMessage(self->h0_, NULL, NULL, NULL, NULL,
 146                                         MOJO_READ_MESSAGE_FLAG_MAY_DISCARD);
 147     MOJO_ALLOW_UNUSED_LOCAL(result);
 148     assert(result == MOJO_RESULT_SHOULD_WAIT);
 149   }
 150
 151  protected:
 152 #if !defined(WIN32)
 153   void DoMessagePipeThreadedTest(unsigned num_writers,
 154                                  unsigned num_readers,
 155                                  uint32_t num_bytes) {
 156     static const int64_t kPerftestTimeMicroseconds = 3 * 1000000;
 157
 158     assert(num_writers > 0);
 159     assert(num_readers > 0);
 160
 161     MojoResult result = MojoCreateMessagePipe(NULL, &h0_, &h1_);
 162     MOJO_ALLOW_UNUSED_LOCAL(result);
 163     assert(result == MOJO_RESULT_OK);
 164
 165     std::vector<MessagePipeWriterThread*> writers;
 166     for (unsigned i = 0; i < num_writers; i++)
 167       writers.push_back(new MessagePipeWriterThread(h0_, num_bytes));
 168
 169     std::vector<MessagePipeReaderThread*> readers;
 170     for (unsigned i = 0; i < num_readers; i++)
 171       readers.push_back(new MessagePipeReaderThread(h1_));
 172
 173     // Start time here, just before we fire off the threads.
 174     const MojoTimeTicks start_time = MojoGetTimeTicksNow();
 175
 176     // Interleave the starts.
 177     for (unsigned i = 0; i < num_writers || i < num_readers; i++) {
 178       if (i < num_writers)
 179         writers[i]->Start();
 180       if (i < num_readers)
 181         readers[i]->Start();
 182     }
 183
 184     Sleep(kPerftestTimeMicroseconds);
 185
 186     // Close both handles to make writers and readers stop immediately.
 187     result = MojoClose(h0_);
 188     assert(result == MOJO_RESULT_OK);
 189     result = MojoClose(h1_);
 190     assert(result == MOJO_RESULT_OK);
 191
 192     // Join everything.
 193     for (unsigned i = 0; i < num_writers; i++)
 194       writers[i]->Join();
 195     for (unsigned i = 0; i < num_readers; i++)
 196       readers[i]->Join();
 197
 198     // Stop time here.
 199     MojoTimeTicks end_time = MojoGetTimeTicksNow();
 200
 201     // Add up write and read counts, and destroy the threads.
 202     int64_t num_writes = 0;
 203     for (unsigned i = 0; i < num_writers; i++) {
 204       num_writes += writers[i]->num_writes();
 205       delete writers[i];
 206     }
 207     writers.clear();
 208     int64_t num_reads = 0;
 209     for (unsigned i = 0; i < num_readers; i++) {
 210       num_reads += readers[i]->num_reads();
 211       delete readers[i];
 212     }
 213     readers.clear();
 214
 215     char test_name[200];
 216     sprintf(test_name,
 217             "MessagePipe_Threaded_Writes_%uw_%ur_%ubytes",
 218             num_writers,
 219             num_readers,
 220             static_cast<unsigned>(num_bytes));
 221     mojo::test::LogPerfResult(
 222         test_name,
 223         1000000.0 * static_cast<double>(num_writes) / (end_time - start_time),
 224         "writes/second");
 225     sprintf(test_name,
 226             "MessagePipe_Threaded_Reads_%uw_%ur_%ubytes",
 227             num_writers,
 228             num_readers,
 229             static_cast<unsigned>(num_bytes));
 230     mojo::test::LogPerfResult(
 231         test_name,
 232         1000000.0 * static_cast<double>(num_reads) / (end_time - start_time),
 233         "reads/second");
 234   }
 235 #endif  // !defined(WIN32)
 236
 237   MojoHandle h0_;
 238   MojoHandle h1_;
 239
 240   void* buffer_;
 241   uint32_t num_bytes_;
 242
 243  private:
 244 #if !defined(WIN32)
 245   void Sleep(int64_t microseconds) {
 246     struct timespec req = {
 247         static_cast<time_t>(microseconds / 1000000),       // Seconds.
 248         static_cast<long>(microseconds % 1000000) * 1000L  // Nanoseconds.
 249     };
 250     int rv = nanosleep(&req, NULL);
 251     MOJO_ALLOW_UNUSED_LOCAL(rv);
 252     assert(rv == 0);
 253   }
 254 #endif  // !defined(WIN32)
 255
 256   MOJO_DISALLOW_COPY_AND_ASSIGN(CorePerftest);
 257 };
 258
 259 // A no-op test so we can compare performance.
 260 TEST_F(CorePerftest, NoOp) {
 261   mojo::test::IterateAndReportPerf("NoOp", &CorePerftest::NoOp, this);
 262 }
 263
 264 TEST_F(CorePerftest, MessagePipe_CreateAndClose) {
 265   mojo::test::IterateAndReportPerf("MessagePipe_CreateAndClose",
 266                                    &CorePerftest::MessagePipe_CreateAndClose,
 267                                    this);
 268 }
 269
 270 TEST_F(CorePerftest, MessagePipe_WriteAndRead) {
 271   MojoResult result = MojoCreateMessagePipe(NULL, &h0_, &h1_);
 272   MOJO_ALLOW_UNUSED_LOCAL(result);
 273   assert(result == MOJO_RESULT_OK);
 274   char buffer[10000] = {0};
 275   buffer_ = buffer;
 276   num_bytes_ = 10u;
 277   mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead_10bytes",
 278                                    &CorePerftest::MessagePipe_WriteAndRead,
 279                                    this);
 280   num_bytes_ = 100u;
 281   mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead_100bytes",
 282                                    &CorePerftest::MessagePipe_WriteAndRead,
 283                                    this);
 284   num_bytes_ = 1000u;
 285   mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead_1000bytes",
 286                                    &CorePerftest::MessagePipe_WriteAndRead,
 287                                    this);
 288   num_bytes_ = 10000u;
 289   mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead_10000bytes",
 290                                    &CorePerftest::MessagePipe_WriteAndRead,
 291                                    this);
 292   result = MojoClose(h0_);
 293   assert(result == MOJO_RESULT_OK);
 294   result = MojoClose(h1_);
 295   assert(result == MOJO_RESULT_OK);
 296 }
 297
 298 TEST_F(CorePerftest, MessagePipe_EmptyRead) {
 299   MojoResult result = MojoCreateMessagePipe(NULL, &h0_, &h1_);
 300   MOJO_ALLOW_UNUSED_LOCAL(result);
 301   assert(result == MOJO_RESULT_OK);
 302   mojo::test::IterateAndReportPerf(
 303       "MessagePipe_EmptyRead", &CorePerftest::MessagePipe_EmptyRead, this);
 304   result = MojoClose(h0_);
 305   assert(result == MOJO_RESULT_OK);
 306   result = MojoClose(h1_);
 307   assert(result == MOJO_RESULT_OK);
 308 }
 309
 310 #if !defined(WIN32)
 311 TEST_F(CorePerftest, MessagePipe_Threaded) {
 312   DoMessagePipeThreadedTest(1u, 1u, 100u);
 313   DoMessagePipeThreadedTest(2u, 2u, 100u);
 314   DoMessagePipeThreadedTest(3u, 3u, 100u);
 315   DoMessagePipeThreadedTest(10u, 10u, 100u);
 316   DoMessagePipeThreadedTest(10u, 1u, 100u);
 317   DoMessagePipeThreadedTest(1u, 10u, 100u);
 318
 319   // For comparison of overhead:
 320   DoMessagePipeThreadedTest(1u, 1u, 10u);
 321   // 100 was done above.
 322   DoMessagePipeThreadedTest(1u, 1u, 1000u);
 323   DoMessagePipeThreadedTest(1u, 1u, 10000u);
 324
 325   DoMessagePipeThreadedTest(3u, 3u, 10u);
 326   // 100 was done above.
 327   DoMessagePipeThreadedTest(3u, 3u, 1000u);
 328   DoMessagePipeThreadedTest(3u, 3u, 10000u);
 329 }
 330 #endif  // !defined(WIN32)
 331
 332 }  // namespace