1 // Copyright 2013 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_PROFILER_ALLOCATION_TRACKER_H_ 6 #define V8_PROFILER_ALLOCATION_TRACKER_H_ 7 8 #include <map> 9 #include <vector> 10 11 #include "include/v8-profiler.h" 12 #include "src/base/hashmap.h" 13 #include "src/handles.h" 14 #include "src/vector.h" 15 16 namespace v8 { 17 namespace internal { 18 19 // Forward declarations. 20 class AllocationTraceTree; 21 class AllocationTracker; 22 class HeapObjectsMap; 23 class SharedFunctionInfo; 24 class StringsStorage; 25 26 class AllocationTraceNode { 27 public: 28 AllocationTraceNode(AllocationTraceTree* tree, 29 unsigned function_info_index); 30 ~AllocationTraceNode(); 31 AllocationTraceNode* FindChild(unsigned function_info_index); 32 AllocationTraceNode* FindOrAddChild(unsigned function_info_index); 33 void AddAllocation(unsigned size); 34 function_info_index()35 unsigned function_info_index() const { return function_info_index_; } allocation_size()36 unsigned allocation_size() const { return total_size_; } allocation_count()37 unsigned allocation_count() const { return allocation_count_; } id()38 unsigned id() const { return id_; } children()39 const std::vector<AllocationTraceNode*>& children() const { 40 return children_; 41 } 42 43 void Print(int indent, AllocationTracker* tracker); 44 45 private: 46 AllocationTraceTree* tree_; 47 unsigned function_info_index_; 48 unsigned total_size_; 49 unsigned allocation_count_; 50 unsigned id_; 51 std::vector<AllocationTraceNode*> children_; 52 53 DISALLOW_COPY_AND_ASSIGN(AllocationTraceNode); 54 }; 55 56 57 class AllocationTraceTree { 58 public: 59 AllocationTraceTree(); 60 ~AllocationTraceTree(); 61 AllocationTraceNode* AddPathFromEnd(const Vector<unsigned>& path); root()62 AllocationTraceNode* root() { return &root_; } next_node_id()63 unsigned next_node_id() { return next_node_id_++; } 64 void Print(AllocationTracker* tracker); 65 66 private: 67 unsigned next_node_id_; 68 AllocationTraceNode root_; 69 70 DISALLOW_COPY_AND_ASSIGN(AllocationTraceTree); 71 }; 72 73 74 class AddressToTraceMap { 75 public: 76 void AddRange(Address addr, int size, unsigned node_id); 77 unsigned GetTraceNodeId(Address addr); 78 void MoveObject(Address from, Address to, int size); 79 void Clear(); size()80 size_t size() { return ranges_.size(); } 81 void Print(); 82 83 private: 84 struct RangeStack { RangeStackRangeStack85 RangeStack(Address start, unsigned node_id) 86 : start(start), trace_node_id(node_id) {} 87 Address start; 88 unsigned trace_node_id; 89 }; 90 // [start, end) -> trace 91 typedef std::map<Address, RangeStack> RangeMap; 92 93 void RemoveRange(Address start, Address end); 94 95 RangeMap ranges_; 96 }; 97 98 class AllocationTracker { 99 public: 100 struct FunctionInfo { 101 FunctionInfo(); 102 const char* name; 103 SnapshotObjectId function_id; 104 const char* script_name; 105 int script_id; 106 int line; 107 int column; 108 }; 109 110 AllocationTracker(HeapObjectsMap* ids, StringsStorage* names); 111 ~AllocationTracker(); 112 113 void PrepareForSerialization(); 114 void AllocationEvent(Address addr, int size); 115 trace_tree()116 AllocationTraceTree* trace_tree() { return &trace_tree_; } function_info_list()117 const std::vector<FunctionInfo*>& function_info_list() const { 118 return function_info_list_; 119 } address_to_trace()120 AddressToTraceMap* address_to_trace() { return &address_to_trace_; } 121 122 private: 123 unsigned AddFunctionInfo(SharedFunctionInfo* info, SnapshotObjectId id); 124 unsigned functionInfoIndexForVMState(StateTag state); 125 126 class UnresolvedLocation { 127 public: 128 UnresolvedLocation(Script* script, int start, FunctionInfo* info); 129 ~UnresolvedLocation(); 130 void Resolve(); 131 132 private: 133 static void HandleWeakScript(const v8::WeakCallbackInfo<void>& data); 134 135 Handle<Script> script_; 136 int start_position_; 137 FunctionInfo* info_; 138 }; 139 140 static const int kMaxAllocationTraceLength = 64; 141 HeapObjectsMap* ids_; 142 StringsStorage* names_; 143 AllocationTraceTree trace_tree_; 144 unsigned allocation_trace_buffer_[kMaxAllocationTraceLength]; 145 std::vector<FunctionInfo*> function_info_list_; 146 base::HashMap id_to_function_info_index_; 147 std::vector<UnresolvedLocation*> unresolved_locations_; 148 unsigned info_index_for_other_state_; 149 AddressToTraceMap address_to_trace_; 150 151 DISALLOW_COPY_AND_ASSIGN(AllocationTracker); 152 }; 153 154 } // namespace internal 155 } // namespace v8 156 157 #endif // V8_PROFILER_ALLOCATION_TRACKER_H_ 158