Transition POSIX shmem to use lockf(), not semaphores.

base/shared_memory_unittest.cc

 // Copyright (c) 2006-2008 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/basictypes.h"
+#include "base/multiprocess_test.h"
 #include "base/platform_thread.h"
 #include "base/scoped_nsautorelease_pool.h"
 #include "base/shared_memory.h"
+#include "base/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 static const int kNumThreads = 5;
+static const int kNumTasks = 5;
 
 namespace base {
 
 namespace {
 
 // Each thread will open the shared memory.  Each thread will take a different 4
 // byte int pointer, and keep changing it, with some small pauses in between.
 // Verify that each thread's value in the shared memory is always correct.
 class MultipleThreadMain : public PlatformThread::Delegate {
  public:
@@ skipping 129 matching lines @@
 
   // Close the second memory segment.
   memory2.Close();
 
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory2.Delete(test_name);
   EXPECT_TRUE(rv);
 }
 
-// Create a set of 5 threads to each open a shared memory segment and write to
+// Create a set of N threads to each open a shared memory segment and write to
 // it. Verify that they are always reading/writing consistent data.
 TEST(SharedMemoryTest, MultipleThreads) {
   MultipleThreadMain::CleanUp();
-  PlatformThreadHandle thread_handles[kNumThreads];
-  MultipleThreadMain* thread_delegates[kNumThreads];
+  // On POSIX we have a problem when 2 threads try to create the shmem
+  // (a file) at exactly the same time, since create both creates the
+  // file and zerofills it.  We solve the problem for this unit test
+  // (make it not flaky) by starting with 1 thread, then
+  // intentionally don't clean up its shmem before running with
+  // kNumThreads.
 
-  // Spawn the threads.
-  for (int16 index = 0; index < kNumThreads; index++) {
-    PlatformThreadHandle pth;
-    thread_delegates[index] = new MultipleThreadMain(index);
-    EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
-    thread_handles[index] = pth;
+  int threadcounts[] = { 1, kNumThreads };
+  for (size_t i = 0; i < sizeof(threadcounts) / sizeof(threadcounts); i++) {
+    int numthreads = threadcounts[i];
+    scoped_array<PlatformThreadHandle> thread_handles;
+    scoped_array<MultipleThreadMain*> thread_delegates;
+
+    thread_handles.reset(new PlatformThreadHandle[numthreads]);
+    thread_delegates.reset(new MultipleThreadMain*[numthreads]);
+
+    // Spawn the threads.
+    for (int16 index = 0; index < numthreads; index++) {
+      PlatformThreadHandle pth;
+      thread_delegates[index] = new MultipleThreadMain(index);
+      EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
+      thread_handles[index] = pth;
+    }
+
+    // Wait for the threads to finish.
+    for (int index = 0; index < numthreads; index++) {
+      PlatformThread::Join(thread_handles[index]);
+      delete thread_delegates[index];
+    }
   }
-
-  // Wait for the threads to finish.
-  for (int index = 0; index < kNumThreads; index++) {
-    PlatformThread::Join(thread_handles[index]);
-    delete thread_delegates[index];
-  }
-
   MultipleThreadMain::CleanUp();
 }
 
 // TODO(port): this test requires the MultipleLockThread class
 // (defined above), which requires the ability to pass file
 // descriptors between processes.  We haven't done that yet in Chrome
 // for POSIX.
 #if defined(OS_WIN)
 // Create a set of threads to each open a shared memory segment and write to it
 // with the lock held. Verify that they are always reading/writing consistent
@@ skipping 20 matching lines @@
 
 // Allocate private (unique) shared memory with an empty string for a
 // name.  Make sure several of them don't point to the same thing as
 // we might expect if the names are equal.
 TEST(SharedMemoryTest, AnonymousPrivate) {
   int i, j;
   int count = 4;
   bool rv;
   const int kDataSize = 8192;
 
-  SharedMemory* memories = new SharedMemory[count];
-  int **pointers = new int*[count];
-  ASSERT_TRUE(memories);
-  ASSERT_TRUE(pointers);
+  scoped_array<SharedMemory> memories(new SharedMemory[count]);
+  scoped_array<int*> pointers(new int*[count]);
+  ASSERT_TRUE(memories.get());
+  ASSERT_TRUE(pointers.get());
 
   for (i = 0; i < count; i++) {
     rv = memories[i].Create(L"", false, true, kDataSize);
     EXPECT_TRUE(rv);
     rv = memories[i].Map(kDataSize);
     EXPECT_TRUE(rv);
     int *ptr = static_cast<int*>(memories[i].memory());
     EXPECT_TRUE(ptr);
     pointers[i] = ptr;
   }
@@ skipping 11 matching lines @@
       if (i == j)
         EXPECT_EQ(100, pointers[j][0]);
       else
         EXPECT_EQ(0, pointers[j][0]);
     }
   }
 
   for (int i = 0; i < count; i++) {
     memories[i].Close();
   }
+
+}
+
+
+// On POSIX it is especially important we test shmem across processes,
+// not just across threads.  But the test is enabled on all platforms.
+class SharedMemoryProcessTest : public MultiProcessTest {
+ public:
+
+  static void CleanUp() {
+    SharedMemory memory;
+    memory.Delete(test_name_);
+  }
+
+  static int TaskTestMain() {
+    int errors = 0;
+    ScopedNSAutoreleasePool pool;  // noop if not OSX
+    const int kDataSize = 1024;
+    SharedMemory memory;
+    bool rv = memory.Create(test_name_, false, true, kDataSize);
+    EXPECT_TRUE(rv);
+    if (rv != true)
+      errors++;
+    rv = memory.Map(kDataSize);
+    EXPECT_TRUE(rv);
+    if (rv != true)
+      errors++;
+    int *ptr = static_cast<int*>(memory.memory());
+
+    for (int idx = 0; idx < 20; idx++) {
+      memory.Lock();
+      int i = (1 << 16) + idx;
+      *ptr = i;
+      PlatformThread::Sleep(10);  // Short wait.
+      if (*ptr != i)
+        errors++;
+      memory.Unlock();
+    }
+
+    memory.Close();
+    return errors;
+  }
+
+ private:
+  static const std::wstring test_name_;
+};
+
+const std::wstring SharedMemoryProcessTest::test_name_ = L"MPMem";
+
+
+TEST_F(SharedMemoryProcessTest, Tasks) {
+  SharedMemoryProcessTest::CleanUp();
+
+  base::ProcessHandle handles[kNumTasks];
+  for (int index = 0; index < kNumTasks; ++index) {
+    handles[index] = SpawnChild(L"SharedMemoryTestMain");
+  }
+
+  int exit_code = 0;
+  for (int index = 0; index < kNumTasks; ++index) {
+    EXPECT_TRUE(base::WaitForExitCode(handles[index], &exit_code));
+    EXPECT_TRUE(exit_code == 0);
+  }
+
+  SharedMemoryProcessTest::CleanUp();
+}
+
+MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
+  return SharedMemoryProcessTest::TaskTestMain();
 }
 
 
 }  // namespace base