[WIP][tracing] Add memory dump provider for sync Directory

sync/syncable/parent_child_index.cc

 // Copyright (c) 2012 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 "sync/syncable/parent_child_index.h"
 
 #include "base/stl_util.h"
 
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/syncable_id.h"
@@ skipping 25 matching lines @@
     DCHECK(!b->ref(UNIQUE_POSITION).IsValid());
     // Sort by META_HANDLE to ensure consistent order for testing.
     return a->ref(META_HANDLE) < b->ref(META_HANDLE);
   }
 }
 
 ParentChildIndex::ParentChildIndex() {
   // Pre-allocate these two vectors to the number of model types.
   model_type_root_ids_.resize(MODEL_TYPE_COUNT);
   type_root_child_sets_.resize(MODEL_TYPE_COUNT);
+  bytes_used_ =
+      MODEL_TYPE_COUNT * (sizeof(Id) + sizeof(OrderedChildSet*)) + sizeof(this);
 }
 
 ParentChildIndex::~ParentChildIndex() {
   for (int i = 0; i < MODEL_TYPE_COUNT; i++) {
     // Normally all OrderedChildSet instances in |type_root_child_sets_|
     // are shared with |parent_children_map_|. Null out shared instances and
     // ScopedVector will take care of the ones that are not shared (if any).
     if (!model_type_root_ids_[i].IsNull()) {
       DCHECK_EQ(type_root_child_sets_[i],
                 parent_children_map_.find(model_type_root_ids_[i])->second);
@@ skipping 20 matching lines @@
 
   if (ShouldUseParentId(parent_id, model_type)) {
     // Hierarchical type, lookup child set in the map.
     DCHECK(!parent_id.IsNull());
     ParentChildrenMap::iterator it = parent_children_map_.find(parent_id);
     if (it != parent_children_map_.end()) {
       siblings = it->second;
     } else {
       siblings = new OrderedChildSet();
       parent_children_map_.insert(std::make_pair(parent_id, siblings));
+      bytes_used_ += parent_id.value().capacity() + sizeof(OrderedChildSet);

[stanisc, 2016/07/06 21:50:32]

I would prefer to not mix the code for the size estimation with the rest of the
logic. It would be cleaner to calculate the size on demand.

[ssid, 2016/07/19 22:10:35]

counting the usage on demand.

     }
   } else {
     // Non-hierarchical type, return a pre-defined collection by type.
     siblings = GetOrCreateModelTypeChildSet(model_type);
   }
 
   // If this is one of type root folder for a non-hierarchical type, associate
   // its ID with the model type and the type's pre-defined child set with the
   // type root ID.
   // TODO(stanisc): crbug/438313: Just TypeSupportsHierarchy condition should
   // theoretically be sufficient but in practice many tests don't properly
   // initialize entries so TypeSupportsHierarchy ends up failing. Consider
   // tweaking TypeSupportsHierarchy and fixing all related test code.
   if (parent_id.IsRoot() && entry->ref(IS_DIR) &&
       syncer::IsRealDataType(model_type) &&
       !TypeSupportsHierarchy(model_type)) {
     const Id& type_root_id = entry->ref(ID);
     // Disassociate the type root child set with the previous ID if any.
     const Id& prev_type_root_id = model_type_root_ids_[model_type];
     if (!prev_type_root_id.IsNull()) {
       ParentChildrenMap::iterator it =
           parent_children_map_.find(prev_type_root_id);
       if (it != parent_children_map_.end()) {
         // If the entry exists in the map it must already have the same
         // model type specific child set. This child set will be re-inserted
         // in the map under the new ID below so it is safe to simply erase
         // the entry here.
         DCHECK_EQ(it->second, GetModelTypeChildSet(model_type));
+        bytes_used_ -=
+            2 * it->first.value().capacity() + sizeof(OrderedChildSet*);
         parent_children_map_.erase(it);
       }
     }
     // Store the new type root ID and associate the child set.
     // Note that the child set isn't owned by the map in this case.
     model_type_root_ids_[model_type] = type_root_id;
     parent_children_map_.insert(
         std::make_pair(type_root_id, GetOrCreateModelTypeChildSet(model_type)));
+    bytes_used_ +=
+        2 * type_root_id.value().capacity() + sizeof(OrderedChildSet*);

[stanisc, 2016/07/06 21:50:32]

This doesn't take into account sizeof(Id) which should be ~32 bytes. Also I
don't think you need to double the capacity. Internally characters are stored in
UTF-8 rather than unicode.

Also you need to add one to the capacity because it doesn't count the
terminating zero (here and everywhere capacity is used).

I recommend that you look at the actual binary layout with a debugger.

[ssid, 2016/07/19 22:10:35]

Oh the 2 is multiplied not for the encoding. It is because the string is stored
twice, once at model_type_root_ids_ and once at parent_children_map_. I have
moved the calculation to the usage function, that should be clear.

   }
 
   // Finally, insert the entry in the child set.
+  bytes_used_ += sizeof(EntryKernel*);

[stanisc, 2016/07/06 21:50:32]

This is a bit simplistic. See this:
http://info.prelert.com/blog/stl-container-memory-usage

Also this doesn't take into account the dynamic growth. When you add an entry in
the map the underlying storage sometimes doesn't grow at all, and sometimes it
doubles. That all depends on the implementation of course.

[ssid, 2016/07/19 22:10:35]

Fixed with more accurate values.

   return siblings->insert(entry).second;
 }
 
 // Like the other containers used to help support the syncable::Directory, this
 // one does not own any EntryKernels.  This function removes references to the
 // given EntryKernel but does not delete it.
 void ParentChildIndex::Remove(EntryKernel* e) {
   OrderedChildSet* siblings = nullptr;
   ModelType model_type = e->GetModelType();
   const Id& parent_id = e->ref(PARENT_ID);
@@ skipping 10 matching lines @@
   } else {
     // Non-hierarchical type, return a pre-defined child set by type.
     siblings = type_root_child_sets_[model_type];
   }
 
   OrderedChildSet::iterator j = siblings->find(e);
   DCHECK(j != siblings->end());
 
   // Erase the entry from the child set.
   siblings->erase(j);
+  bytes_used_ -= sizeof(EntryKernel*);
   // If the set is now empty and isn't shareable with |type_root_child_sets_|,
   // erase it from the map.
   if (siblings->empty() && should_erase) {
     delete siblings;
+    bytes_used_ -= it->first.value().capacity() + sizeof(OrderedChildSet);
     parent_children_map_.erase(it);
   }
 }
 
 bool ParentChildIndex::Contains(EntryKernel *e) const {
   const OrderedChildSet* siblings = GetChildSet(e);
   return siblings && siblings->count(e) > 0;
 }
 
 const OrderedChildSet* ParentChildIndex::GetChildren(const Id& id) const {
@@ skipping 61 matching lines @@
     type_root_child_sets_[model_type] = new OrderedChildSet();
   return type_root_child_sets_[model_type];
 }
 
 const Id& ParentChildIndex::GetModelTypeRootId(ModelType model_type) const {
   return model_type_root_ids_[model_type];
 }
 
 }  // namespace syncable
 }  // namespace syncer