ipc: Add basic memory usage tests for attachment brokering.

ipc/attachment_broker_mac_unittest.cc

 // Copyright 2015 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 <fcntl.h>
+#include <mach/mach_vm.h>
 #include <sys/mman.h>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/mac/mac_util.h"
+#include "base/mac/mach_logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/synchronization/spin_wait.h"
+#include "base/time/time.h"
 #include "ipc/attachment_broker_messages.h"
 #include "ipc/attachment_broker_privileged_mac.h"
 #include "ipc/attachment_broker_unprivileged_mac.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_messages.h"
 #include "ipc/test_util_mac.h"
 
 namespace {
 
 const char kDataBuffer1[] = "This is some test data to write to the file.";
 const char kDataBuffer2[] = "The lazy dog and a fox.";
 const char kDataBuffer3[] = "Two green bears but not a potato.";
 const char kDataBuffer4[] = "Red potato is best potato.";
 const std::string g_service_switch_name = "service_name";
+const size_t g_large_message_size = 8 * 1024 * 1024;
+const int g_large_message_count = 1000;
+const size_t g_medium_message_size = 512 * 1024;
+
+// Running the message loop is expected to increase the number of resident
+// pages. The exact amount is non-deterministic, but for a simple test suite
+// like this one, the increase is expected to be less than 1 MB.
+const size_t g_expected_memory_increase = 1024 * 1024;
 
 enum TestResult {
   RESULT_UNKNOWN,
   RESULT_SUCCESS,
   RESULT_FAILURE,
 };
 
+mach_vm_size_t GetResidentSize() {
+  task_basic_info_64 info;
+  mach_msg_type_number_t count = TASK_BASIC_INFO_64_COUNT;
+  kern_return_t kr = task_info(mach_task_self(), TASK_BASIC_INFO_64,
+                               reinterpret_cast<task_info_t>(&info), &count);
+  MACH_CHECK(kr == KERN_SUCCESS, kr) << "Couldn't get resident size.";
+
+  return info.resident_size;
+}
+
 base::mac::ScopedMachSendRight GetMachPortFromBrokeredAttachment(
     const scoped_refptr<IPC::BrokerableAttachment>& attachment) {
   if (attachment->GetType() !=
       IPC::BrokerableAttachment::TYPE_BROKERABLE_ATTACHMENT) {
     LOG(INFO) << "Attachment type not TYPE_BROKERABLE_ATTACHMENT.";
     return base::mac::ScopedMachSendRight(MACH_PORT_NULL);
   }
 
   if (attachment->GetBrokerableType() != IPC::BrokerableAttachment::MACH_PORT) {
     LOG(INFO) << "Brokerable type not MACH_PORT.";
@@ skipping 361 matching lines @@
   }
 
   void CheckChildResult() {
     ASSERT_EQ(ProxyListener::MESSAGE_RECEIVED,
               get_proxy_listener()->get_reason());
     ASSERT_EQ(get_result_listener()->get_result(), RESULT_SUCCESS);
   }
 
   void FinalCleanUp() {
     // There should be no leaked names.
+    SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(
+        base::TimeDelta::FromSeconds(10),
+        active_names_at_start_ == IPC::GetActiveNameCount());
     EXPECT_EQ(active_names_at_start_, IPC::GetActiveNameCount());
 
     // Close the channel so the client's OnChannelError() gets fired.
     channel()->Close();
 
     EXPECT_TRUE(WaitForClientShutdown());
     DestroyChannel();
     broker_.reset();
   }
 
@@ skipping 43 matching lines @@
 // Channels.
 struct ChildProcessGlobals {
   MockPortProvider port_provider;
 
   // The broker must be destroyed before the port_provider, so that the broker
   // gets a chance to unregister itself as an observer. This doesn't matter
   // outside of tests, since neither port_provider nor broker will ever be
   // destroyed.
   scoped_ptr<IPC::AttachmentBrokerPrivilegedMac> broker;
   base::mac::ScopedMachSendRight server_task_port;
+
+  // Total resident memory before running the message loop.
+  mach_vm_size_t initial_resident_size;
+
+  // Whether to emit log statements while processing messages.
+  bool message_logging;
 };
 
 using OnMessageReceivedCallback = void (*)(IPC::Sender* sender,
                                            const IPC::Message& message,
                                            ChildProcessGlobals* globals);
 
 // Sets up the Mach communication ports with the server. Returns a set of
 // globals that must live at least as long as the test.
 scoped_ptr<ChildProcessGlobals> CommonChildProcessSetUp() {
   base::CommandLine cmd_line = *base::CommandLine::ForCurrentProcess();
   std::string service_name =
       cmd_line.GetSwitchValueASCII(g_service_switch_name);
   base::mac::ScopedMachSendRight server_port(
       IPC::LookupServer(service_name.c_str()));
   base::mac::ScopedMachReceiveRight client_port(IPC::MakeReceivingPort());
 
   // Send the port that this process is listening on to the server.
   IPC::SendMachPort(
       server_port.get(), client_port.get(), MACH_MSG_TYPE_MAKE_SEND);
 
   // Receive the task port of the server process.
   base::mac::ScopedMachSendRight server_task_port(
       IPC::ReceiveMachPort(client_port.get()));
 
   scoped_ptr<ChildProcessGlobals> globals(new ChildProcessGlobals);
   globals->broker.reset(
       new IPC::AttachmentBrokerPrivilegedMac(&globals->port_provider));
   globals->port_provider.InsertEntry(getppid(), server_task_port.get());
   globals->server_task_port.reset(server_task_port.release());
+  globals->message_logging = true;
   return globals;
 }
 
 int CommonPrivilegedProcessMain(OnMessageReceivedCallback callback,
                                 const char* channel_name) {
   LOG(INFO) << "Privileged process start.";
   scoped_ptr<ChildProcessGlobals> globals(CommonChildProcessSetUp());
 
   mach_msg_type_number_t active_names_at_start = IPC::GetActiveNameCount();
 
   base::MessageLoopForIO main_message_loop;
   ProxyListener listener;
 
   scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
       IPCTestBase::GetChannelName(channel_name), &listener));
   globals->broker->RegisterCommunicationChannel(channel.get());
   CHECK(channel->Connect());
 
+  globals->initial_resident_size = GetResidentSize();
+
   while (true) {
-    LOG(INFO) << "Privileged process spinning run loop.";
+    if (globals->message_logging)
+      LOG(INFO) << "Privileged process spinning run loop.";
     base::MessageLoop::current()->Run();
     ProxyListener::Reason reason = listener.get_reason();
     if (reason == ProxyListener::CHANNEL_ERROR)
       break;
 
     while (listener.has_message()) {
-      LOG(INFO) << "Privileged process running callback.";
+      if (globals->message_logging)
+        LOG(INFO) << "Privileged process running callback.";
       callback(channel.get(), listener.get_first_message(), globals.get());
-      LOG(INFO) << "Privileged process finishing callback.";
+      if (globals->message_logging)
+        LOG(INFO) << "Privileged process finishing callback.";
       listener.pop_first_message();
     }
   }
 
   if (active_names_at_start != IPC::GetActiveNameCount()) {
     LOG(INFO) << "Memory leak!.";
   }
   LOG(INFO) << "Privileged process end.";
   return 0;
 }
@@ skipping 593 matching lines @@
     globals->port_provider.InsertEntry(pid, task_port);
   }
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandleToSelfDelayedPort) {
   return CommonPrivilegedProcessMain(
       &SendSharedMemoryHandleToSelfDelayedPortCallback,
       "SendSharedMemoryHandleToSelfDelayedPort");
 }
 
+// Tests the memory usage characteristics of attachment brokering a single large
+// message. This test has the *potential* to be flaky, since it compares
+// resident memory at different points in time, and that measurement is
+// non-deterministic.
+TEST_F(IPCAttachmentBrokerMacTest, MemoryUsageLargeMessage) {
+  // Mach-based SharedMemory isn't support on OSX 10.6.
+  if (base::mac::IsOSSnowLeopard())
+    return;
+
+  CommonSetUp("MemoryUsageLargeMessage");
+
+  std::string test_string(g_large_message_size, 'a');
+  SendMessage1(test_string);
+  base::MessageLoop::current()->Run();
+  CommonTearDown();
+}
+
+void MemoryUsageLargeMessageCallback(IPC::Sender* sender,
+                                     const IPC::Message& message,
+                                     ChildProcessGlobals* globals) {
+  EXPECT_LE(GetResidentSize(),
+            globals->initial_resident_size + g_expected_memory_increase);
+
+  base::SharedMemoryHandle shm(GetSharedMemoryHandleFromMsg1(message));
+  scoped_ptr<base::SharedMemory> shared_memory(
+      MapSharedMemoryHandle(shm, false));
+  EXPECT_LE(GetResidentSize(),
+            globals->initial_resident_size + g_expected_memory_increase);
+
+  // Volatile prevents the compiler from optimizing out |c|.
+  volatile char c = '\0';

[Tom Sepez, 2015/11/20 17:23:03]

I suspect that an aggressive optimizer may be able to pull this anyhow, since it
can prove that c is unused, and that its address can't be aliased with any other
pointers, etc.

I think you want static_cast<volatile char*>(addr) which tells the compiler that
the addr changes unpredictably and that the act of reading it may have some
side-effect (like auto-incrementing device registers should they be mapped
there).

[erikchen, 2015/11/20 19:01:20]

I spent some time thinking about this, and decided that your suggestion was
correct, and that my previous code was incorrect.

+  void* addr = shared_memory->memory();
+  for (size_t i = 0; i < g_large_message_size; i += 1024) {
+    c += static_cast<char*>(addr)[i];
+  }
+  EXPECT_GE(GetResidentSize(),
+            globals->initial_resident_size + g_large_message_size);
+
+  shared_memory.reset();
+  EXPECT_LE(GetResidentSize(),
+            globals->initial_resident_size + g_expected_memory_increase);
+
+  SendControlMessage(sender, true);
+}
+
+MULTIPROCESS_IPC_TEST_CLIENT_MAIN(MemoryUsageLargeMessage) {
+  return CommonPrivilegedProcessMain(&MemoryUsageLargeMessageCallback,
+                                     "MemoryUsageLargeMessage");
+}
+
+// Tests the memory usage characteristics of attachment brokering many small
+// messages. This test has the *potential* to be flaky, since it compares
+// resident memory at different points in time, and that measurement is
+// non-deterministic.
+TEST_F(IPCAttachmentBrokerMacTest, MemoryUsageManyMessages) {
+  // Mach-based SharedMemory isn't support on OSX 10.6.
+  if (base::mac::IsOSSnowLeopard())
+    return;
+
+  CommonSetUp("MemoryUsageManyMessages");
+
+  for (int i = 0; i < g_large_message_count; ++i) {
+    std::string message = base::IntToString(i);
+    message += '\0';
+    size_t end = message.size();
+    message.resize(g_medium_message_size);
+    std::fill(message.begin() + end, message.end(), 'a');
+    SendMessage1(message);
+
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+
+  if (get_result_listener()->get_result() == RESULT_UNKNOWN)
+    base::MessageLoop::current()->Run();
+
+  CommonTearDown();
+}
+
+void MemoryUsageManyMessagesCallback(IPC::Sender* sender,
+                                     const IPC::Message& message,
+                                     ChildProcessGlobals* globals) {
+  // Volatile prevents the compiler from optimizing out |c|.
+  static volatile char c = '\0';
+  static int message_index = 0;
+
+  {
+    // Map the shared memory, and make sure that its pages are counting towards
+    // resident size.
+    base::SharedMemoryHandle shm(GetSharedMemoryHandleFromMsg1(message));
+    scoped_ptr<base::SharedMemory> shared_memory(
+        MapSharedMemoryHandle(shm, false));
+
+    char* addr = static_cast<char*>(shared_memory->memory());
+    std::string message_string(addr);
+    int message_int;
+    ASSERT_TRUE(base::StringToInt(message_string, &message_int));
+    ASSERT_EQ(message_index, message_int);
+    for (size_t i = 0; i < g_medium_message_size; i += 1024) {
+      c += static_cast<char*>(addr)[i];
+    }
+  }
+
+  ++message_index;
+
+  if (message_index == 1) {
+    // Disable message logging, since it significantly contributes towards total
+    // memory usage.
+    LOG(INFO) << "Disable privileged process message logging.";
+    globals->message_logging = false;
+  }
+
+  if (message_index == g_large_message_count) {
+    size_t memory_increase_kb =
+        (GetResidentSize() - globals->initial_resident_size) / 1024;
+    LOG(INFO) << "Increase in memory usage in KB: " << memory_increase_kb;
+
+    // The total increase in resident size should be less than 1MB. The exact
+    // amount is not deterministic.
+    bool success = memory_increase_kb < 1024;
+    SendControlMessage(sender, success);
+  }
+}
+
+MULTIPROCESS_IPC_TEST_CLIENT_MAIN(MemoryUsageManyMessages) {
+  return CommonPrivilegedProcessMain(&MemoryUsageManyMessagesCallback,
+                                     "MemoryUsageManyMessages");
+}
+
 }  // namespace