Home | History | Annotate | Download | only in profiler 
      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 
     10 #include "include/v8-profiler.h"
     11 #include "src/handles.h"
     12 #include "src/hashmap.h"
     13 #include "src/list.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   Vector<AllocationTraceNode*> children() const { return children_.ToVector(); }
     40 
     41   void Print(int indent, AllocationTracker* tracker);
     42 
     43  private:
     44   AllocationTraceTree* tree_;
     45   unsigned function_info_index_;
     46   unsigned total_size_;
     47   unsigned allocation_count_;
     48   unsigned id_;
     49   List<AllocationTraceNode*> children_;
     50 
     51   DISALLOW_COPY_AND_ASSIGN(AllocationTraceNode);
     52 };
     53 
     54 
     55 class AllocationTraceTree {
     56  public:
     57   AllocationTraceTree();
     58   ~AllocationTraceTree();
     59   AllocationTraceNode* AddPathFromEnd(const Vector<unsigned>& path);
     60   AllocationTraceNode* root() { return &root_; }
     61   unsigned next_node_id() { return next_node_id_++; }
     62   void Print(AllocationTracker* tracker);
     63 
     64  private:
     65   unsigned next_node_id_;
     66   AllocationTraceNode root_;
     67 
     68   DISALLOW_COPY_AND_ASSIGN(AllocationTraceTree);
     69 };
     70 
     71 
     72 class AddressToTraceMap {
     73  public:
     74   void AddRange(Address addr, int size, unsigned node_id);
     75   unsigned GetTraceNodeId(Address addr);
     76   void MoveObject(Address from, Address to, int size);
     77   void Clear();
     78   size_t size() { return ranges_.size(); }
     79   void Print();
     80 
     81  private:
     82   struct RangeStack {
     83     RangeStack(Address start, unsigned node_id)
     84         : start(start), trace_node_id(node_id) {}
     85     Address start;
     86     unsigned trace_node_id;
     87   };
     88   // [start, end) -> trace
     89   typedef std::map<Address, RangeStack> RangeMap;
     90 
     91   void RemoveRange(Address start, Address end);
     92 
     93   RangeMap ranges_;
     94 };
     95 
     96 class AllocationTracker {
     97  public:
     98   struct FunctionInfo {
     99     FunctionInfo();
    100     const char* name;
    101     SnapshotObjectId function_id;
    102     const char* script_name;
    103     int script_id;
    104     int line;
    105     int column;
    106   };
    107 
    108   AllocationTracker(HeapObjectsMap* ids, StringsStorage* names);
    109   ~AllocationTracker();
    110 
    111   void PrepareForSerialization();
    112   void AllocationEvent(Address addr, int size);
    113 
    114   AllocationTraceTree* trace_tree() { return &trace_tree_; }
    115   const List<FunctionInfo*>& function_info_list() const {
    116     return function_info_list_;
    117   }
    118   AddressToTraceMap* address_to_trace() { return &address_to_trace_; }
    119 
    120  private:
    121   unsigned AddFunctionInfo(SharedFunctionInfo* info, SnapshotObjectId id);
    122   static void DeleteFunctionInfo(FunctionInfo** info);
    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(
    133         const v8::WeakCallbackData<v8::Value, void>& data);
    134 
    135     Handle<Script> script_;
    136     int start_position_;
    137     FunctionInfo* info_;
    138   };
    139   static void DeleteUnresolvedLocation(UnresolvedLocation** location);
    140 
    141   static const int kMaxAllocationTraceLength = 64;
    142   HeapObjectsMap* ids_;
    143   StringsStorage* names_;
    144   AllocationTraceTree trace_tree_;
    145   unsigned allocation_trace_buffer_[kMaxAllocationTraceLength];
    146   List<FunctionInfo*> function_info_list_;
    147   HashMap id_to_function_info_index_;
    148   List<UnresolvedLocation*> unresolved_locations_;
    149   unsigned info_index_for_other_state_;
    150   AddressToTraceMap address_to_trace_;
    151 
    152   DISALLOW_COPY_AND_ASSIGN(AllocationTracker);
    153 };
    154 
    155 }  // namespace internal
    156 }  // namespace v8
    157 
    158 #endif  // V8_ALLOCATION_TRACKER_H_
    159