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             :   AllocationTraceNode* root() { return &root_; }
      63         300 :   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();
      80             :   size_t size() { return ranges_.size(); }
      81             :   void Print();
      82             : 
      83             :  private:
      84             :   struct RangeStack {
      85             :     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             : 
     116             :   AllocationTraceTree* trace_tree() { return &trace_tree_; }
     117             :   const std::vector<FunctionInfo*>& function_info_list() const {
     118             :     return function_info_list_;
     119             :   }
     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_