Add DiscardableMemoryAllocator to work around FD limit issue.

base/memory/discardable_memory.h

 // Copyright (c) 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.
 
 #ifndef BASE_MEMORY_DISCARDABLE_MEMORY_H_
 #define BASE_MEMORY_DISCARDABLE_MEMORY_H_
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 26 matching lines @@
 //     memory, use it as quickly as possible, and then unlock it.
 //   - Because of memory alignment, the amount of memory allocated can be
 //     larger than the requested memory size. It is not very efficient for
 //     small allocations.
 //
 // References:
 //   - Linux: http://lwn.net/Articles/452035/
 //   - Mac: http://trac.webkit.org/browser/trunk/Source/WebCore/platform/mac/PurgeableBufferMac.cpp
 //          the comment starting with "vm_object_purgable_control" at
 //            http://www.opensource.apple.com/source/xnu/xnu-792.13.8/osfmk/vm/vm_object.c
+//
+// Thread-safety: DiscardableMemory instances are not thread-safe.

[pasko, 2013/10/25 15:21:13]

nit: It should probably also say somewhere that it returns NULL if out of 
resources, and clients should be ready to fallback to heap allocations.

[Philippe, 2013/10/28 09:44:43]

Good point although David wants to move to a point of reliability where
discardable memory allocations can be considered as malloc failures (i.e.
fatal): https://code.google.com/p/chromium/issues/detail?id=310231

If you don't mind I will let him address or not your comment :)

[reveman, 2013/10/28 15:45:23]

If the platform specific DM implementation requires fallback to heap
allocations, then I'd like to see that handled automatically by the DM system
using emulated DM buffers instead of pushing the responsibility to the client.
However, emulated DM need to land before we can do this of course.

[Philippe, 2013/10/28 15:49:14]

+1 to that.

 class BASE_EXPORT DiscardableMemory {
  public:
   virtual ~DiscardableMemory() {}
 
   // Returns whether the system supports discardable memory.
   static bool Supported();
 
   static scoped_ptr<DiscardableMemory> CreateLockedMemory(size_t size);
 
+  // Returns the memory's actual size that is greater or equal than the
+  // size requested at construction.
+  virtual size_t Size() const = 0;
+
   // Locks the memory so that it will not be purged by the system. Returns
   // DISCARDABLE_MEMORY_SUCCESS on success. If the return value is
   // DISCARDABLE_MEMORY_FAILED then this object should be discarded and
   // a new one should be created. If the return value is
   // DISCARDABLE_MEMORY_PURGED then the memory is present but any data that
   // was in it is gone.
   virtual LockDiscardableMemoryStatus Lock() WARN_UNUSED_RESULT = 0;
 
   // Unlocks the memory so that it can be purged by the system. Must be called
   // after every successful lock call.
@@ skipping 10 matching lines @@
   static bool PurgeForTestingSupported();
 
   // Purge all discardable memory in the system. This call has global effects
   // across all running processes, so it should only be used for testing!
   static void PurgeForTesting();
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_DISCARDABLE_MEMORY_H_