Line data    Source code

       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             : 
      35             :   unsigned function_info_index() const { return function_info_index_; }
      36             :   unsigned allocation_size() const { return total_size_; }
      37             :   unsigned allocation_count() const { return allocation_count_; }
      38             :   unsigned id() const { return id_; }
      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          35 :   ~AllocationTraceTree() = default;
      61             :   AllocationTraceNode* AddPathFromEnd(const Vector<unsigned>& path);
      62      115650 :   AllocationTraceNode* root() { return &root_; }
      63         300 :   unsigned next_node_id() { return next_node_id_++; }
      64             :   V8_EXPORT_PRIVATE 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          40 : class V8_EXPORT_PRIVATE AddressToTraceMap {
      74             :  public:
      75             :   void AddRange(Address addr, int size, unsigned node_id);
      76             :   unsigned GetTraceNodeId(Address addr);
      77             :   void MoveObject(Address from, Address to, int size);
      78             :   void Clear();
      79             :   size_t size() { return ranges_.size(); }
      80             :   void Print();
      81             : 
      82             :  private:
      83             :   struct RangeStack {
      84             :     RangeStack(Address start, unsigned node_id)
      85             :         : start(start), trace_node_id(node_id) {}
      86             :     Address start;
      87             :     unsigned trace_node_id;
      88             :   };
      89             :   // [start, end) -> trace
      90             :   typedef std::map<Address, RangeStack> RangeMap;
      91             : 
      92             :   void RemoveRange(Address start, Address end);
      93             : 
      94             :   RangeMap ranges_;
      95             : };
      96             : 
      97             : class AllocationTracker {
      98             :  public:
      99             :   struct FunctionInfo {
     100             :     FunctionInfo();
     101             :     const char* name;
     102             :     SnapshotObjectId function_id;
     103             :     const char* script_name;
     104             :     int script_id;
     105             :     int line;
     106             :     int column;
     107             :   };
     108             : 
     109             :   AllocationTracker(HeapObjectsMap* ids, StringsStorage* names);
     110             :   ~AllocationTracker();
     111             : 
     112             :   V8_EXPORT_PRIVATE void PrepareForSerialization();
     113             :   void AllocationEvent(Address addr, int size);
     114             : 
     115          30 :   AllocationTraceTree* trace_tree() { return &trace_tree_; }
     116             :   const std::vector<FunctionInfo*>& function_info_list() const {
     117             :     return function_info_list_;
     118             :   }
     119       67793 :   AddressToTraceMap* address_to_trace() { return &address_to_trace_; }
     120             : 
     121             :  private:
     122             :   unsigned AddFunctionInfo(SharedFunctionInfo info, SnapshotObjectId id);
     123             :   unsigned functionInfoIndexForVMState(StateTag state);
     124             : 
     125             :   class UnresolvedLocation {
     126             :    public:
     127             :     UnresolvedLocation(Script script, int start, FunctionInfo* info);
     128             :     ~UnresolvedLocation();
     129             :     void Resolve();
     130             : 
     131             :    private:
     132             :     static void HandleWeakScript(const v8::WeakCallbackInfo<void>& data);
     133             : 
     134             :     Handle<Script> script_;
     135             :     int start_position_;
     136             :     FunctionInfo* info_;
     137             :   };
     138             : 
     139             :   static const int kMaxAllocationTraceLength = 64;
     140             :   HeapObjectsMap* ids_;
     141             :   StringsStorage* names_;
     142             :   AllocationTraceTree trace_tree_;
     143             :   unsigned allocation_trace_buffer_[kMaxAllocationTraceLength];
     144             :   std::vector<FunctionInfo*> function_info_list_;
     145             :   base::HashMap id_to_function_info_index_;
     146             :   std::vector<UnresolvedLocation*> unresolved_locations_;
     147             :   unsigned info_index_for_other_state_;
     148             :   AddressToTraceMap address_to_trace_;
     149             : 
     150             :   DISALLOW_COPY_AND_ASSIGN(AllocationTracker);
     151             : };
     152             : 
     153             : }  // namespace internal
     154             : }  // namespace v8
     155             : 
     156             : #endif  // V8_PROFILER_ALLOCATION_TRACKER_H_