Update mojo sdk to rev cc531b32182099a5a034a99daff35ed5d38a61c8

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

 // Copyright 2013 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.
 
 // This tests the performance of the C API.
 
 #include "mojo/public/c/system/core.h"
 
 #include <assert.h>
 #include <stddef.h>
@@ skipping 194 matching lines @@
       delete writers[i];
     }
     writers.clear();
     int64_t num_reads = 0;
     for (unsigned i = 0; i < num_readers; i++) {
       num_reads += readers[i]->num_reads();
       delete readers[i];
     }
     readers.clear();
 
-    char test_name[200];
-    sprintf(test_name,
-            "MessagePipe_Threaded_Writes_%uw_%ur_%ubytes",
-            num_writers,
-            num_readers,
+    char sub_test_name[200];
+    sprintf(sub_test_name, "%uw_%ur_%ubytes", num_writers, num_readers,
             static_cast<unsigned>(num_bytes));
     mojo::test::LogPerfResult(
-        test_name,
+        "MessagePipe_Threaded_Writes", sub_test_name,
         1000000.0 * static_cast<double>(num_writes) / (end_time - start_time),
         "writes/second");
-    sprintf(test_name,
-            "MessagePipe_Threaded_Reads_%uw_%ur_%ubytes",
-            num_writers,
-            num_readers,
-            static_cast<unsigned>(num_bytes));
     mojo::test::LogPerfResult(
-        test_name,
+        "MessagePipe_Threaded_Reads", sub_test_name,
         1000000.0 * static_cast<double>(num_reads) / (end_time - start_time),
         "reads/second");
   }
 #endif  // !defined(WIN32)
 
   MojoHandle h0_;
   MojoHandle h1_;
 
   void* buffer_;
   uint32_t num_bytes_;
 
  private:
 #if !defined(WIN32)
   void Sleep(int64_t microseconds) {
     struct timespec req = {
         static_cast<time_t>(microseconds / 1000000),       // Seconds.
         static_cast<long>(microseconds % 1000000) * 1000L  // Nanoseconds.
     };
     int rv = nanosleep(&req, NULL);
     MOJO_ALLOW_UNUSED_LOCAL(rv);
     assert(rv == 0);
   }
 #endif  // !defined(WIN32)
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(CorePerftest);
 };
 
 // A no-op test so we can compare performance.
 TEST_F(CorePerftest, NoOp) {
-  mojo::test::IterateAndReportPerf("NoOp", &CorePerftest::NoOp, this);
+  mojo::test::IterateAndReportPerf("Iterate_NoOp", nullptr, &CorePerftest::NoOp,
+                                   this);
 }
 
 TEST_F(CorePerftest, MessagePipe_CreateAndClose) {
-  mojo::test::IterateAndReportPerf("MessagePipe_CreateAndClose",
+  mojo::test::IterateAndReportPerf("MessagePipe_CreateAndClose", nullptr,
                                    &CorePerftest::MessagePipe_CreateAndClose,
                                    this);
 }
 
 TEST_F(CorePerftest, MessagePipe_WriteAndRead) {
   MojoResult result = MojoCreateMessagePipe(NULL, &h0_, &h1_);
   MOJO_ALLOW_UNUSED_LOCAL(result);
   assert(result == MOJO_RESULT_OK);
   char buffer[10000] = {0};
   buffer_ = buffer;
   num_bytes_ = 10u;
-  mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead_10bytes",
+  mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead", "10bytes",
                                    &CorePerftest::MessagePipe_WriteAndRead,
                                    this);
   num_bytes_ = 100u;
-  mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead_100bytes",
+  mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead", "100bytes",
                                    &CorePerftest::MessagePipe_WriteAndRead,
                                    this);
   num_bytes_ = 1000u;
-  mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead_1000bytes",
+  mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead", "1000bytes",
                                    &CorePerftest::MessagePipe_WriteAndRead,
                                    this);
   num_bytes_ = 10000u;
-  mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead_10000bytes",
+  mojo::test::IterateAndReportPerf("MessagePipe_WriteAndRead", "10000bytes",
                                    &CorePerftest::MessagePipe_WriteAndRead,
                                    this);
   result = MojoClose(h0_);
   assert(result == MOJO_RESULT_OK);
   result = MojoClose(h1_);
   assert(result == MOJO_RESULT_OK);
 }
 
 TEST_F(CorePerftest, MessagePipe_EmptyRead) {
   MojoResult result = MojoCreateMessagePipe(NULL, &h0_, &h1_);
   MOJO_ALLOW_UNUSED_LOCAL(result);
   assert(result == MOJO_RESULT_OK);
-  mojo::test::IterateAndReportPerf(
-      "MessagePipe_EmptyRead", &CorePerftest::MessagePipe_EmptyRead, this);
+  mojo::test::IterateAndReportPerf("MessagePipe_EmptyRead", nullptr,
+                                   &CorePerftest::MessagePipe_EmptyRead, this);
   result = MojoClose(h0_);
   assert(result == MOJO_RESULT_OK);
   result = MojoClose(h1_);
   assert(result == MOJO_RESULT_OK);
 }
 
 #if !defined(WIN32)
 TEST_F(CorePerftest, MessagePipe_Threaded) {
   DoMessagePipeThreadedTest(1u, 1u, 100u);
   DoMessagePipeThreadedTest(2u, 2u, 100u);
   DoMessagePipeThreadedTest(3u, 3u, 100u);
   DoMessagePipeThreadedTest(10u, 10u, 100u);
   DoMessagePipeThreadedTest(10u, 1u, 100u);
   DoMessagePipeThreadedTest(1u, 10u, 100u);
 
   // For comparison of overhead:
   DoMessagePipeThreadedTest(1u, 1u, 10u);
   // 100 was done above.
   DoMessagePipeThreadedTest(1u, 1u, 1000u);
   DoMessagePipeThreadedTest(1u, 1u, 10000u);
 
   DoMessagePipeThreadedTest(3u, 3u, 10u);
   // 100 was done above.
   DoMessagePipeThreadedTest(3u, 3u, 1000u);
   DoMessagePipeThreadedTest(3u, 3u, 10000u);
 }
 #endif  // !defined(WIN32)
 
 }  // namespace