Implemented basic heap memory allocation tracking in MallocHooks using hooks registered with tcmall…

runtime/vm/hash_map.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_HASH_MAP_H_
 #define RUNTIME_VM_HASH_MAP_H_
 
 #include "vm/growable_array.h"  // For Malloc, EmptyBase
 #include "vm/zone.h"
 
@@ skipping 15 matching lines @@
   }
 
   BaseDirectChainedHashMap(const BaseDirectChainedHashMap& other);
 
   ~BaseDirectChainedHashMap() {
     allocator_->template Free<HashMapListElement>(array_, array_size_);
     allocator_->template Free<HashMapListElement>(lists_, lists_size_);
   }
 
   void Insert(typename KeyValueTrait::Pair kv);
+  bool Remove(typename KeyValueTrait::Key key);
 
   typename KeyValueTrait::Value LookupValue(
       typename KeyValueTrait::Key key) const;
 
   typename KeyValueTrait::Pair* Lookup(typename KeyValueTrait::Key key) const;
 
   bool IsEmpty() const { return count_ == 0; }
 
   void Clear() {
     if (!IsEmpty()) {
@@ skipping 255 matching lines @@
     free_list_head_ = lists_[free_list_head_].next;
     lists_[new_element_pos].kv = kv;
     lists_[new_element_pos].next = array_[pos].next;
     ASSERT(array_[pos].next == kNil ||
            KeyValueTrait::ValueOf(lists_[array_[pos].next].kv) != kNoValue);
     array_[pos].next = new_element_pos;
   }
 }
 
 
+template <typename KeyValueTrait, typename B, typename Allocator>
+bool BaseDirectChainedHashMap<KeyValueTrait, B, Allocator>::Remove(
+    typename KeyValueTrait::Key key) {
+  uword pos = Bound(static_cast<uword>(KeyValueTrait::Hashcode(key)));
+
+  // Check to see if the first element in the bucket is the one we want to
+  // remove.
+  if (KeyValueTrait::KeyOf(array_[pos].kv) == key) {
+    if (array_[pos].next == kNil) {
+      array_[pos] = HashMapListElement();
+    } else {
+      intptr_t next = array_[pos].next;
+      array_[pos] = lists_[next];
+      lists_[next] = HashMapListElement();
+      lists_[next].next = free_list_head_;
+      free_list_head_ = next;
+    }
+    count_--;
+    return true;
+  }
+
+  intptr_t current = array_[pos].next;
+
+  // Check the case where the second element in the bucket is the one to be
+  // removed.
+  if (KeyValueTrait::KeyOf(lists_[current].kv) == key) {
+    array_[pos].next = lists_[current].next;
+    lists_[current] = HashMapListElement();
+    lists_[current].next = free_list_head_;
+    free_list_head_ = current;
+    count_--;
+    return true;
+  }
+
+  // Finally, iterate through the rest of the bucket to see if we can find the
+  // entry that matches our key.
+  intptr_t previous;
+  while (KeyValueTrait::KeyOf(lists_[current].kv) != key) {
+    previous = current;
+    current = lists_[current].next;
+
+    if (current == kNil) {
+      // Could not find entry with provided key to remove.
+      return false;
+    }
+  }
+
+  lists_[previous].next = lists_[current].next;
+  lists_[current] = HashMapListElement();
+  lists_[current].next = free_list_head_;
+  free_list_head_ = current;
+  count_--;
+  return true;
+}
+
+
 template <typename KeyValueTrait>
 class DirectChainedHashMap
     : public BaseDirectChainedHashMap<KeyValueTrait, ValueObject> {
  public:
   DirectChainedHashMap()
       : BaseDirectChainedHashMap<KeyValueTrait, ValueObject>(
             ASSERT_NOTNULL(Thread::Current()->zone())) {}
 };
 
 
@@ skipping 53 matching lines @@
 
   static Key KeyOf(Pair kv) { return kv.key; }
   static Value ValueOf(Pair kv) { return kv.value; }
   static intptr_t Hashcode(Key key) { return reinterpret_cast<intptr_t>(key); }
   static bool IsKeyEqual(Pair kv, Key key) { return kv.key == key; }
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_HASH_MAP_H_