[tracing] Display the locked size of discardable memory segment.

base/memory/discardable_shared_memory.h

 // Copyright 2014 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_SHARED_MEMORY_H_
 #define BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_
 
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 38 matching lines @@
   bool Map(size_t size);
 
   // Unmaps the discardable shared memory from the caller's address space.
   // Returns true if successful; returns false on error or if the memory is
   // not mapped.
   bool Unmap();
 
   // The actual size of the mapped memory (may be larger than requested).
   size_t mapped_size() const { return mapped_size_; }
 
+  // The total size of locked segments by this instance of
+  // DiscardableSharedMemory. If the memory is shared with other process,
+  // then returns the total size of the segment if locked.
+  size_t LockedSize() const;

[reveman, 2015/09/29 12:29:10]

I assume you're interested in being able to call this from any process and not
just the process locking the segment. LockedSize() doesn't make sense for that
as only the process locking the memory will know how much is locked. "bool
IsMemoryLocked() const" would work. If you add such a function, please keep it
next to "IsMemoryResident()".

I'm not sure we should expose the value of locked_page_count_ as that will be
confusing from a multi-process usage pov. I think it might be better to keep
track of this in each child process using the DiscardableSharedMemoryHeap spans.

[ssid, 2015/09/29 16:03:55]

Maybe I should just rename it? instead of calculating these outside or make it
private method and friend or something?
Hm, this looks like lot of change to me, I have adding the lock state in span
also moved lock and unlock feature to span itself. This is because everytime
someone wants to unlock the span they should remember to update the span locked
state. Curently manager was just using span->shared_memory()->Lock, now it will
use span::Lock. If not for the lock mechanism, I would have removed the
ChildDiscardableSharedMemoryManager::Lock and directly called span->Lock in
DiscardableMemoryImpl. But this feels a bit weird that the impl now has two
choices, it can span->lock or manager->lock(span). But calling manager is thread
safe.
Also I had to hard code true and false for span constructor.

Should I just store the locked state and update it everytime memory is locked
and unlocked?

+
   // Returns a shared memory handle for this DiscardableSharedMemory object.
   SharedMemoryHandle handle() const { return shared_memory_.handle(); }
 
   // Locks a range of memory so that it will not be purged by the system.
   // The range of memory must be unlocked. The result of trying to lock an
   // already locked range is undefined. |offset| and |length| must both be
   // a multiple of the page size as returned by GetPageSize().
   // Passing 0 for |length| means "everything onward".
   // Returns SUCCESS if range was successfully locked and the memory is still
   // resident, PURGED if range was successfully locked but has been purged
@@ skipping 72 matching lines @@
   // synchronized somehow. Use a collision warner to detect incorrect usage.
   DFAKE_MUTEX(thread_collision_warner_);
   Time last_known_usage_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemory);
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_