Added page to Observatory to display native memory allocation information.

runtime/vm/profiler_service.h

 // Copyright (c) 2015, 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_PROFILER_SERVICE_H_
 #define RUNTIME_VM_PROFILER_SERVICE_H_
 
 #include "vm/allocation.h"
 #include "vm/code_observers.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
+#include "vm/hash_map.h"
 #include "vm/object.h"
 #include "vm/tags.h"
 #include "vm/thread_interrupter.h"
 #include "vm/token_position.h"
 
 // CPU Profile model and service protocol bits.
 // NOTE: For sampling and stack walking related code, see profiler.h.
 
 namespace dart {
 
 // Forward declarations.
 class Code;
 class Function;
 class JSONArray;
 class JSONStream;
 class ProfileFunctionTable;
 class ProfileCodeTable;
 class RawCode;
 class RawFunction;
 class SampleFilter;
+class ProcessedSample;
 class ProcessedSampleBuffer;
 
+class AllocationKeyValueTrait {
+ public:
+  typedef intptr_t Key;

[Cutch, 2017/03/16 20:38:16]

what is the key?

[bkonyi, 2017/03/16 20:48:40]

Size of the allocation. Will add comment/better name if we decide to keep memory
information in the Profile(Code|Function) objects.

[bkonyi, 2017/03/21 01:53:24]

Removed.

+  typedef intptr_t Value;

[Cutch, 2017/03/16 20:38:16]

what is the value?

[bkonyi, 2017/03/16 20:48:40]

The number of allocations of the size represented by the key. Will add
comment/better name if we decide to keep memory information in the
Profile(Code|Function) objects.

[bkonyi, 2017/03/21 01:53:24]

Removed.

+
+  struct Pair {
+    Key key;
+    Value value;
+    Pair() : key(), value(-1) {}
+    Pair(const Key key, const Value value) : key(key), value(value) {}
+    Pair(const Pair& other) : key(other.key), value(other.value) {}
+  };
+
+  static Key KeyOf(Pair kv) { return kv.key; }
+  static Value ValueOf(Pair kv) { return kv.value; }
+  static uintptr_t Hashcode(Key key) { return key; }
+  static bool IsKeyEqual(Pair kv, Key key) { return kv.key == key; }
+};
+
+typedef DirectChainedHashMap<AllocationKeyValueTrait> AllocationHashMap;
+
 class ProfileFunctionSourcePosition {
  public:
   explicit ProfileFunctionSourcePosition(TokenPosition token_pos);
 
   void Tick(bool exclusive);
 
   TokenPosition token_pos() const { return token_pos_; }
   intptr_t exclusive_ticks() const { return exclusive_ticks_; }
   intptr_t inclusive_ticks() const { return inclusive_ticks_; }
 
@@ skipping 32 matching lines @@
   const Function* function() const { return &function_; }
 
   bool is_visible() const;
 
   intptr_t table_index() const { return table_index_; }
 
   Kind kind() const { return kind_; }
 
   intptr_t exclusive_ticks() const { return exclusive_ticks_; }
   intptr_t inclusive_ticks() const { return inclusive_ticks_; }
-
   void IncInclusiveTicks() { inclusive_ticks_++; }
-
   void Tick(bool exclusive,
             intptr_t inclusive_serial,
-            TokenPosition token_position);
+            TokenPosition token_position,
+            ProcessedSample* sample);
+
+  bool contains_native_allocation() const {
+    return contains_native_allocation_;
+  }
 
   static const char* KindToCString(Kind kind);
 
   void PrintToJSONArray(JSONArray* functions);
 
   // Returns true if the call was successful and |pfsp| is set.
   bool GetSinglePosition(ProfileFunctionSourcePosition* pfsp);
 
   void TickSourcePosition(TokenPosition token_position, bool exclusive);
 
@@ skipping 10 matching lines @@
   const char* name_;
   const Function& function_;
   const intptr_t table_index_;
   ZoneGrowableArray<intptr_t> profile_codes_;
   ZoneGrowableArray<ProfileFunctionSourcePosition> source_position_ticks_;
 
   intptr_t exclusive_ticks_;
   intptr_t inclusive_ticks_;
   intptr_t inclusive_serial_;
 
+  void AccumulateAllocation(intptr_t allocation_size, bool exclusive);
+  bool contains_native_allocation_;
+  AllocationHashMap exclusive_native_allocations_;
+  AllocationHashMap inclusive_native_allocations_;
+
   void PrintToJSONObject(JSONObject* func);
   // A |ProfileCode| that contains this function.
   void AddProfileCode(intptr_t code_table_index);
 
   friend class ProfileCode;
   friend class ProfileBuilder;
 };
 
 
 class ProfileCodeAddress {
@@ skipping 54 matching lines @@
     exclusive_ticks_ = exclusive_ticks;
   }
   void IncExclusiveTicks() { exclusive_ticks_++; }
 
   intptr_t inclusive_ticks() const { return inclusive_ticks_; }
   void set_inclusive_ticks(intptr_t inclusive_ticks) {
     inclusive_ticks_ = inclusive_ticks;
   }
   void IncInclusiveTicks() { inclusive_ticks_++; }
 
+  bool contains_native_allocation() const {
+    return contains_native_allocation_;
+  }
+
   bool IsOptimizedDart() const;
   RawCode* code() const { return code_.raw(); }
 
   const char* name() const { return name_; }
   void SetName(const char* name);
   void GenerateAndSetSymbolName(const char* prefix);
 
   static const char* KindToCString(Kind kind);
 
   void PrintToJSONArray(JSONArray* codes);
 
  private:
-  void Tick(uword pc, bool exclusive, intptr_t serial);
+  void Tick(uword pc, bool exclusive, intptr_t serial, ProcessedSample* sample);
   void TickAddress(uword pc, bool exclusive);
+  void AccumulateAllocation(intptr_t allocation_size, bool exclusive);
 
   ProfileFunction* SetFunctionAndName(ProfileFunctionTable* table);
 
   ProfileFunction* function() const { return function_; }
 
   void PrintNativeCode(JSONObject* profile_code_obj);
   void PrintCollectedCode(JSONObject* profile_code_obj);
   void PrintOverwrittenCode(JSONObject* profile_code_obj);
   void PrintTagCode(JSONObject* profile_code_obj);
 
   void set_code_table_index(intptr_t index) { code_table_index_ = index; }
   intptr_t code_table_index() const { return code_table_index_; }
 
   const Kind kind_;
   uword start_;
   uword end_;
   intptr_t exclusive_ticks_;
   intptr_t inclusive_ticks_;
   intptr_t inclusive_serial_;
 
+  AllocationHashMap exclusive_native_allocations_;
+  AllocationHashMap inclusive_native_allocations_;
+  bool contains_native_allocation_;
+
   const Code& code_;
   char* name_;
   int64_t compile_timestamp_;
   ProfileFunction* function_;
   intptr_t code_table_index_;
   ZoneGrowableArray<ProfileCodeAddress> address_ticks_;
 
   friend class ProfileBuilder;
 };
 
@@ skipping 11 matching lines @@
   virtual ~ProfileTrieNode();
 
   virtual void PrintToJSONArray(JSONArray* array) const = 0;
 
   // Index into function or code tables.
   intptr_t table_index() const { return table_index_; }
 
   intptr_t count() const { return count_; }
 
   void Tick() { count_++; }
+  void IncrementAllocation(intptr_t allocation, bool exclusive) {
+    ASSERT(allocation >= 0);
+    if (exclusive) {
+      exclusive_allocations_ += allocation;
+    }
+    inclusive_allocations_ += allocation;
+  }
 
   intptr_t NumChildren() const { return children_.length(); }
 
   ProfileTrieNode* At(intptr_t i) { return children_.At(i); }
 
   intptr_t IndexOf(ProfileTrieNode* node);
 
   intptr_t frame_id() const { return frame_id_; }
   void set_frame_id(intptr_t id) {
     ASSERT(frame_id_ == -1);
     frame_id_ = id;
   }
 
  protected:
   void SortChildren();
 
   static int ProfileTrieNodeCompare(ProfileTrieNode* const* a,
                                     ProfileTrieNode* const* b) {
     ASSERT(a != NULL);
     ASSERT(b != NULL);
     return (*b)->count() - (*a)->count();
   }
 
 
   intptr_t table_index_;
   intptr_t count_;
+  intptr_t exclusive_allocations_;
+  intptr_t inclusive_allocations_;
   ZoneGrowableArray<ProfileTrieNode*> children_;
   intptr_t frame_id_;
 
   friend class ProfileBuilder;
 };
 
 
 // The model for a profile. Most of the model is zone allocated, therefore
 // a zone must be created that lives longer than this object.
 class Profile : public ValueObject {
@@ skipping 139 matching lines @@
                             JSONStream* stream,
                             Profile::TagOrder tag_order,
                             intptr_t extra_tags,
                             SampleFilter* filter,
                             bool as_timline);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PROFILER_SERVICE_H_